Robert Gruber

Replication in the harp file system

This paper describes the design and implementation of the Harp file system. Harp is a replicated Unix file system accessible via the VFS interface. It provides highly available and reliable storage for files and guarantees that file operations are executed atomically in spite of concurrency and failures. It uses a novel variation of the primary copy replication technique that provides good performance because it allows us to trade disk accesses for network communication. Harp is intended to be used within a file service in a distributed network; in our current implementation, it is accessed via NFS. Preliminary performance results indicate that Harp provides equal or better response time and system capacity than an unreplicated implementation of NFS that uses Unix files directly.

Efficient optimistic concurrency control using loosely synchronized clocks

This paper describes an efficient optimistic concurrency control scheme for use in distributed database systems in which objects are cached and manipulated at client machines while persistent storage and transactional support are provided by servers. The scheme provides both serializability and external consistency for committed transactions; it uses loosely synchronized clocks to achieve global serialization. It stores only a single version of each object, and avoids maintaining any concurrency control information on a per-object basis; instead, it tracks recent invalidations on a per-client basis, an approach that has low in-memory space overhead and no per-object disk overhead. In addition to its low space overheads, the scheme also performs well. The paper presents a simulation study that compares the scheme to adaptive callback locking, the best concurrency control scheme for client-server object-oriented database systems studied to date. The study shows that our scheme outperforms adaptive callback locking for low to moderate contention workloads, and scales better with the number of clients. For high contention workloads, optimism can result in a high abort rate; the scheme presented here is a first step toward a hybrid scheme that we expect to perform well across the full range of workloads.

Safe and efficient sharing of persistent objects in Thor

Thor is an object-oriented database system designed for use in a heterogeneous distributed environment. It provides highly-reliable and highly-available persistent storage for objects, and supports safe sharing of these objects by applications written in different programming languages.Safe heterogeneous sharing of long-lived objects requires encapsulation: the system must guarantee that applications interact with objects only by invoking methods. Although safety concerns are important, most object-oriented databases forgo safety to avoid paying the associated performance costs.This paper gives an overview of Thors design and implementation. We focus on two areas that set Thor apart from other object-oriented databases. First, we discuss safe sharing and techniques for ensuring it; we also discuss ways of improving application performance without sacrificing safety. Second, we describe our approach to cache management at client machines, including a novel adaptive prefetching strategy.The paper presents performance results for Thor, on several OO7 benchmark traversals. The results show that adaptive prefetching is very effective, improving both the elapsed time of traversals and the amount of space used in the client cache. The results also show that the cost of safe sharing can be negligible; thus it is possible to have both safety and high performance.

Subtypes vs. where clauses: constraining parametric polymorphism

All object-oriented languages provide support for subtype polymorphism, which allows the writing of generic code that works for families of related types. There is also a need, however, to write code that is generic across types that have no real family relationship. To satisfy this need a programming language must provide a mechanism for parametric polymorphism, allowing for types as parameters to routines and types. We show that to support modular programming and separate compilation there must be a mechanism for constraining the actual parameters of the routine or type. We describe a simple and powerful constraint mechanism and compare it with constraint mechanisms in other languages in terms of both ease of use and semantic expressiveness. We also discuss the interaction between subtype and parametric polymorphism: we discuss the subtype relations that can exist between instantiations of parameterized types, and which of those relations are useful and can be implemented efficiently. We illustrate our points using examples in Theta, a new object-oriented language, and we describe the time- and space-efficient implementation of parametric polymorphism used in Theta.

A replicated Unix file system

An implementation of a replicated Unix file system for use via the NFS protocol is reported. The replication method is intended to support the following goals: when used via NFS, the system should provide the same semantics as an unreplicated NFS server, and it should be usable with whatever NFS client code exists at the client machine; the system should not depend on proprietary information; the system should continue to provide service even when one replica is crashed or inaccessible, but have only two copies of each file; the system should perform as reliably as a single, unreplicated NFS server; and the system should provide response time comparable to that provided by a single NFS server. In particular, the delay observed by the client in doing a read or write should be no greater than with a single server. The system organization, replication method, performance, and Unix issues are discussed.<<ETX>>

Temperature-based concurrency control

This paper briefly describes the work on concurrency-control algorithms for client-server object-oriented database systems. Other recent relevant work includes the design and implementation of the Harp replicated file system, the design of the Thor object-oriented database system and the design of the Theta object-oriented programming language.<<ETX>>

A replicated Unix file system (extended abstract)

The Programming Methodology group at the Laboratory for Computer Science at M.I.T. is working on an implementation of a replicated Unix file system for use via the NFS protocol [10, 12]. Our replication method is intended to support the following goals: 1. When used via NFS, our system should provide the same semantics as an unreplicated NFS server. Furthermore, it should be usable with whatever NFS client code exists at the client machine.

Efficient recovery in Harp (replicated Unix file system)

Harp is a replicated Unix file system accessible via the VFS interface. It provides highly available and reliable storage for files and guarantees that file operations are executed atomically in spite of concurrency and failures. Replication enables Harp to safely trade disk accesses for network communication and thus to provide good performance both during normal operation and during recovery. The authors focus on the techniques Harp uses to achieve efficient recovery.<<ETX>>