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

Dynamic resource management and automatic configuration of distributed component systems

Abstract: Component technology promotes code-reuse by enabling the construction of complex applications by assembling off-the-shelf components. However, components depend on certain characteristics of the environment in which they execute. They depend on other software components and on hardware resources. In existing component architectures, the application developer is left with the task of resolvig those dependencies, i.e., making sure that each component has asscess to all the resources it needs and that all the required components are loaded. Nevertheless, according to encapsulation principles, developers should not be aware of the component internals. Thus, it may be difficult to find out what a component really need. In complex systems, this manual approach to dependency management can lead to disastrous results. In this paper, we propose an integrated architecture for managing dependencies in distributed component-based systems in an effective and uniform way. The architecture supports automatic configuration and dynamic resource management in distributed heterogeneous environments. We describe a concrete implementation of this architecture and present experimental results.

The design and performance of meta-programming mechanisms for object request broker middleware

Abstract: Distributed object computing (DOC) middleware shields developers from many tedious and error-prone aspects of programming distributed applications. Without proper support from the middleware, however, it can be hard to evolve distributed applications after they are deployed. Therefore, DOC middleware should support meta-programming mechanisms, such as smart proxies and interceptors, that improve the adaptability of distributed applications by allowing their behavior to be modified without changing existing software drastically. This paper presents three contributions to the study of metaprogramming mechanisms for DOC middleware. First, it illustrates, compares, and contrasts several meta-programming mechanisms from an application developer's perspective. Second, it outlines the key design and implementation challenges associated with developing smart proxies and portable interceptors features for CORBA. Third, it presents empirical results that pinpoint the performance impact of smart proxies and interceptors. Our goal is to help researchers and developers determine which meta-programming mechanisms best suit their application requirements.

Kava - using byte code rewriting to add behavioural reflection to Java

Abstract: Many authors have proposed using byte code rewriting as a way of adapting or extending the behaviour of Java classes. There are toolkits available that simplify this process and raise the level of abstraction above byte code. However, to the best of our knowledge, none of these toolkits provide a complete model of behavioural reflection for Java. In this paper, we describe how we have used load-time byte code rewriting techniques to construct a run-time metaobject protocol for Java that can be used to adapt and customise the behaviour of Java classes in a more flexible and abstract way. Apart from providing a better semantic basis for byte code rewriting techniques, our approach also has the advantage over other reflective Java implementations that it doesn't require a modified compiler or JVM, can operate on byte code rather than source code and cannot be bypassed. In this paper we describe the implementation of Kava, our reflective implementation of Java, and discuss some of the linguistic issues and technical challenges involved in implementing such a tool on top of a standard JVM. Kava is available from http://www.cs.ncl.ac.uk/research/dependability/reflection.

Content-based publish/subscribe with structural reflection

Abstract: This paper presents a pragmatic way of implementing content-based publish/subscribe in a strongly typed object-oriented language. In short, we use structural reflection to implement filter objects through which applications express their subscription patterns. Our approach is pragmatic in the sense that it alleviates the need for any specific subscription language. It preserves encapsulation of message objects and helps avoiding errors. We illustrate our approach in the context of Distributed Asynchronous Collections (DACs), programming abstractions for message-oriented interaction. DACs are implemented in Java, whose inherent reflective capabilities fully satisfy the requirements of our content-based subscription scheme. Our approach is however not limited to the context of DACs, but could be put to work easily in other existing event-based systems.

Distributed garbage collection for wide area replicated memory

Abstract: It is well known that distributed systems pose serious difficulties concerning memory management: when done manually, it leads to memory leaks and dangling references causing applications to fail. We address this problem by presenting a distributed garbage collection (DGC) algorithm for distributed systems supporting replicated data over wide area networks. Current DGC algorithms are not well suited for such systems because either (i) they do not consider the existence of replication, or (ii) they impose severe constraints on scalability by requiring causal delivery to be provided by the underlying communication layer. Our algorithm solves these problems by (i) adapting classical reference-counting DGC algorithms that were conceived for non-replicated systems (e.g. indirect reference-counting, SSP chains, etc.), and (ii) improving our previous algorithm for replicated systems (i.e. Larchant). The result is a DGC algorithm that, besides being correct in presence of replicated data and independent of the protocol that maintains such replicas coherent among processes, it does not require causal delivery to be ensured by the underlying communications support. In addition, it has minimal performance impact on applications.

Multi-dispatch in the Java virtual machine: design and implementation

Abstract: Mainstream object-oriented languages, such as C++ and Java, provide only a restricted form of polymorphic methods, namely uni-receiver dispatch. In common programming situations, developers must work around this limitation. We describe how to extend the Java Virtual Machine to support multi-dispatch and examine the complications that Java imposes on multidispatch in practice. Our technique avoids changes to the Java programming language itself, maintains source code and library compatibility, and isolates the performance penalty and semantic changes of multimethod dispatch to the program sections which use it. We have micro-benchmark and application-level performance results for a dynamic Most Specific Applicable (MSA) dispatcher, a framework-based Single Receiver Projections (SRP) dispatcher, and a tuned SRP dispatcher. Our general-purpose technique provides smaller dispatch latency than programmer-written double-dispatch code with equivalent functionality.

Making Java applications mobile or persistent

Abstract: Today, mobility and persistence are important aspects of distributed applications They have many fields of use such as load balancing, fault tolerance and dynamic reconfiguration of applications In this context, the Java virtual machine provides many useful services such as dynamic class loading and object serialization which allow Java code and objects to be mobile or persistent However, Java does not provide any service for the mobility or the persistence of control flows (threads), the execution state of a Java program remains inaccessible We designed and implemented new services that make Java threads mobile or persistent With these services, a running Java thread can, at an arbitrary state of its execution, migrate to a remote machine or be checkpointed on disk for a possible subsequent recovery Therefore migrating a Java thread is simply performed by the call of our go primitive, by the thread itself or by an external thread In other words, the migration or the checkpointing of a thread can be initiated by the thread itself or by another thread We integrated these services into the JVM, so they provide reasonable and competitive performance figures without inducing an overhead on JVM performance Finally, we experimented a dynamic reconfiguration tool based on our mobility service and applied to a running distributed application

Bean markup language: a composition language for JavaBeans components

Abstract: Although the benefits of software component composition are today widely accepted, component oriented software development is not yet as widespread as its multiple advantages may suggest. This is so in spite of the maturity reached by several component models (Microsoft's COM, JavaBeans, OMG's CORBA), and their general acceptance by large communities of developers. Thus, while components are being 'used' in software development, the development process itself is not fully component oriented. One major roadblock limiting the adoption of a component oriented development process is the lack of viable component composition languages. This paper introduces a component composition language specifically designed for the composition of JavaBeans components. The Bean Markup Language (BML) supports component composition in a first-class manner. BML has language constructs for describing inter-component bindings, for constructing aggregates of components, for macro expansion and for implementing certain types of recursive compositions. Further, it allows the specification of "glue code" in any traditional scripting language (for example, JavaScript) to enable powerful adaptation during composition.

Design patterns for generic programming in C

Abstract: Generic programming is a paradigm whose wide adoption by the C++ community is quite recent. In this scheme most classes and procedures are parameterized, leading to the construction of general and efficient software components. In this paper, we show how some design patterns from Gamma et al. can be adapted to this paradigm. Although these patterns rely highly on dynamic binding, we show that, by intensive use of parametric polymorphism, the method calls in these patterns can be resolved at compile-time. In intensive computations, the generic patterns bring a significant speed-up compared to their classical peers.

PSTL: a C++ persistent standard template library

Abstract: The C++ Standard Template Library provides efficient storage of data in containers, and efficient operations on such containers While STL can be parameterized with custom allocators, these cannot be used to add persistency to the container cleasses provided by STL Thus, we have designed the Persistent Standard Template Library (PSTL) that overcomes this by providing its own containers that are compatible with STL, but store their elements on disk This compatibility provides a programming model that is known and more natural to C++ programmers and enables the reuse of many of the algorithms provided by STL in combination with PSTL In this paper we discuss PSTL's design, show the challenges we faced, and how STL's design would have to be extended to provide native support for persistency

HBench: JGC - an application-specific benchmark suite for evaluating JVM garbage collector performance

Abstract: As Java becomes a viable platform for server applications, performance becomes a greater concern. An important aspect of Java Virtual Machine performance is its dynamic memory management system (garbage collection or GC). Traditional GC benchmarking often focuses on a set of fixed applications. As a result, when an actual application's memory behavior differs from that of the standard benchmarks, the benchmark results do not help the user judge which GC implementation suits her application the best. In this paper, we present HBench:JGC, an application-specific benchmarking suite, based on the idea that a system's performance be measured in the context of a specific application. HBench:JGC employs a methodology that characterizes the application memory usage and the GC implementation independently and carefully combines both characterizations to form a single metric that reflects a particular application's performance in the presence of a particular GC implementation. We evaluate our approach on Sun Microsystems's JDK1.2.2 classic JVM with a sequential mark-sweep GC. Our results demonstrate HBench:JGC's unique predictive power and its ability to provide meaningful metrics that lead to a better understanding of GC performance.

TORBA: trading contracts for CORBA

Abstract: Trading is a key function in the context of distributed applications: It allows runtime discovering of available resources. In order to standardize this function, the Open Distributed Processing (ODP) and Object Management Group (OMG) have specified a trading service for CORBA objects: The CosTrading. This specification has two main drawbacks: First, this service is complex to use from applications and second, it does not offer type checking of trading requests at compilation time. Both are discussed in this paper. The main goal of our Trader Oriented Request Broker Architecture (TORBA) is to provide a trading framework and its associated tools, which tend to offer typed trading operations that are simple to use from applications and checked at compilation time. In that, we define the concept of Trading Contracts, written with the TORBA Definition Language (TDL). Such contracts are then compiled to generate trading proxies offering simple-to-use interfaces. These interfaces completely hide the complexity of the ODP/OMG CosTrading APIs. In the meantime, TDL contracts could be dynamically used through a generic graphical console exploiting a contract repository. The example used in this paper, clearly states the advantages brought by the TDL trading contracts: type checking at compilation time, simple to use, and providing a powerful framework for CORBA object trading.

An adaptive data object service for pervasie computing environments

Abstract: Workstations and PCs typically are rich in resources, in contrast to palmtop devices, which are generally quite limited. This disparity offers challenges to integrating these heterogeneous devices into a single distributed system. Services must be available to each device, but it may be necessary to modify certain services if the connected device does not have the desired resources. A key component of many distributed systems is remote access to data. Traditional distributed file systems are typically rather static and are not able to adapt to the current available resources of the devices involved. Data files are treated as continuous streams of bytes and the interfaces to access them are designed for unstructured data: they simply transfer buffers of contiguous data. Providing modality and adapting content using these interfaces proves difficult. In this paper, we present an adaptive data object service for pervasive computing environments using distributed objects. Data is manipulated through an object-oriented interface based on containers and iterators. The interface is also used to model data operations, conversions, and proxies. The system is aware of its environment and can instantiate objects in the proper locations to optimize performance.

Using accessory functions to generalize dynamic dispatch in single-dispatch object-oriented languages

Abstract: Object oriented languages generally include some form of dynamic dispatch; that is, in the absence of precise compile-time type information, they perform a run-time selection of the appropriate function body (or method) from a set of candidates. Existing single-dispatch languages restrict dynamic dispatch to the object receiving the message. Such languages exhibit a conflict between the goals of providing an extensible a set of types and providing an extensible the set of operations that can be performed on these types. We show that this conflict is a consequence of the restriction of dynamic dispatch to the receiver object. We also demonstrate that this conflict can be resolved by introducing a generalized form of single dispatch (thus avoiding the complexity of multiple dispatch). On this evidence, we argue that dispatch technique should be decoupled from membership in a class and access to its representation.