Mark Day

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.

References to remote mobile objects in Thor

Thor is a distributed object-oriented database where objects are stored persistently at highly available servers called object repositories, or ORs. In a large Thor system, performance tuning and system reconfiguration dictate that objects must be able to migrate among ORs. The paper describes two schemes for object references that support object migration, one using location-independent names and the other, location-dependent names. The paper analyzes the performance of the two schemes and concludes that location-dependent names are the right choice for systems like Thor, where we want fast access to objects that have migrated.

What synchronous groupware needs: notification services

Synchronous groupware is the class of applications in which two or more people collaborate in what they perceive to be real time. Most previous efforts to deploy synchronous groupware have failed. The author argues that: synchronous groupware can often be deployed independently of system support for audio, video, or persistent storage; deployment and maintenance of different synchronous groupware applications becomes more reasonable if those applications can share and reuse a common coordination infrastructure, called a notification service; and the most likely way to achieve such sharing and reuse is by the definition of a common notification service protocol. At Lotus, we have designed and implemented such a protocol, called the Notification Service Transfer Protocol (NSTP). Our implementation, called PlaceHolder, has been available from our Web site since November 1996.

Object groups may be better than pages

Argues against trying to solve the problem of clustering objects into disk pages. Instead, the author proposes that objects be fetched in groups that may be specific to an application or user, and that can be computed at fetch time. He briefly describes crystals, which serve to record such groups statically. Finally, I speculate that object fetching may be particularly relevant for providing services to very small machines with limited memory, such as personal digital assistants.<<ETX>>

Lockup of a client object cache and how to avoid it

This paper presents the problem of client object cache lockup in a distributed object-oriented database system where storage is recovered by garbage collection. If garbage collection is augmented with the ability to discard reachable unmodified versions of persistent objects, cache lockup is greatly reduced. This paper outlines some remaining questions about this technique for managing an object cache.<<ETX>>

Replication, reconfiguration, and the Argus mail repository

The Argus Distributed Mail Repository is being implemented to gain experience with a sizable distributed application, to experiment with techniques for building distributed applications that are highly available and scalable, and to evaluate the programming language Argus when used for such applications.This note briefly describes Argus, the goals for the distributed repository, the projects status, and experience to date with the system.