Showing papers by "Barbara Liskov published in 1994"

A behavioral notion of subtyping

Abstract: The use of hierarchy is an important component of object-oriented design. Hierarchy allows the use of type families, in which higher level supertypes capture the behavior that all of their subtypes have in common. For this methodology to be effective, it is necessary to have a clear understanding of how subtypes and supertypes are related. This paper takes the position that the relationship should ensure that any property proved about supertype objects also holds for its subtype objects. It presents two ways of defining the subtype relation, each of which meets this criterion, and each of which is easy for programmers to use. The subtype relation is based on the specifications of the sub- and supertypes; the paper presents a way of specifying types that makes it convenient to define the subtype relation. The paper also discusses the ramifications of this notion of subtyping on the design of type families.

Reducing cross domain call overhead using batched futures

Abstract: In many systems such as operating systems and databases it is important to run client code in a separate protection domain so that it cannot interfere with correct operation of the system. Clients communicate with the server by making cross domain calls, but these are expensive, often costing substantially more than running the call itself. This paper describes a new mechanism called batched futures that transparently batches possibly interrelated client calls. Batching makes domain crossings happen less often, thus substantially reducing the cost. We describe how the mechanism is implemented for the Thor object-oriented database system, and presents performance results showing the benefit of the mechanism on various benchmarks.

Disconnected Operation in the Thor Object-Oriented Database System

Abstract: This paper discusses issaes raised by providing disconnected operation in the Thor object-ortented database system. Disconnected operation in such a system poses new challenges because of the small size of obiects, the richness and complexity of their interconnections, the huge number of them, and the fact that they are accessed within atomic transactions. We propose three techniques to address these challenges: (l) using the database query language for hoarding; (2) using dependent commits to tentatively com' mit transactions at the disconnected client; (3) using the high-level semantic of objects to avoidtransaction aborts.

Fault-tolerant distributed garbage collection in a client-server object-oriented database

Abstract: We present a scalable garbage collection scheme for systems that store objects at multiple servers while clients run transactions on locally cached copies of objects. It is the first scheme that provides fault tolerance for such a system: Servers recover from failures and retrieve information needed for safe garbage collection; clients do not recover from failures, yet the scheme is able to reclaim objects referenced only from failed clients. The scheme is optimized to reduce overhead on common client operations, and it provides fault tolerance by doing work in the background and during client operations that are infrequent. >