This paper presents HAC, a novel technique for managing the client cache in a distributed, persistent object storage system. HAC is a hybrid between page and object caching that combines the virtues of both while avoiding their disadvantages. It achieves the low miss penalties of a page-caching system, but is able to perform well even when locality is poor, since it can discard pages while retaining their hot objects. It realizes the potentially lower miss rates of object-caching systems, yet avoids their problems of fragmentation and high overheads. Furthermore, HAC is adaptive: when locality is good it behaves like a page-caching system, while if locality is poor it behaves like an object-caching system. It is able to adjust the amount of cache space devoted to pages dynamically so that space in the cache can be used in the way that best matches the needs of the application. The paper also presents results of experiments that indicate that HAC outperforms other object storage systems across a wide range of cache sizes and workloads; it performs substantially better on the expected workloads, which have low to moderate locality. Thus we show that our hybrid, adaptive approach is the cache management technique of choice for distributed, persistent object systems. 1

THOR is a persistent object store that provides a powerful programming model. THOR ensures that persistent objects are accessed only by calling their methods and it supports atomic transactions. The result is a system that allows applications to share objects safely across both space and time. The paper

Commercial databases support different isolation levels to allow programmers to trade off consistency for a potential gain in performance. The isolation levels are defined in the current ANSI standard, but the definitions are ambiguous and revised definitions proposed to correct the problem are too constrained since they allow only pessimistic (locking) implementations. This paper presents new specifications for the ANSI levels. Our specifications are portable; they apply not only to locking implementations, but also to optimistic and multi-version concurrency control schemes. Furthermore, unlike earlier definitions, our new specifications handle predicates in a correct and flexible manner at all levels.

Current commercial databases allow application programmers to trade off consistency for performance. However, existing definitions of weak consistency levels are either imprecise or they disallow efficient implementation techniques such as optimism. Ruling out these techniques is especially unfortunate because commercial databases support optimistic mechanisms. Furthermore, optimism is likely to be the implementation technique of choice in the geographically distributed and mobile systems of the future. This thesis presents the first implementation-independent specifications of existing ANSI isolation levels and a number of levels that are widely used in commercial systems, e.g., Cursor Stability, Snapshot Isolation. It also specifies a variety of guarantees for predicate-based operations in an implementation-independent manner. Two new levels are defined that provide useful consistency guarantees to application writers; one is the weakest level that ensures consistent reads, while the other captures some useful consistency properties provided by pessimistic implementations. We

This paper describes a newscheme for guaranteeing that transactions in a client/server system observe consistent state while they are running. The scheme is presented in conjunction with an optimistic concurrency control algorithm, but could also be used to prevent read-only transactions from conflicting with read/write transactions in a multi-version system. The scheme is lazy about the consistency it provides for running transactions and also in the way it generates the consistency information. The paper presents results of simulation experiments showing that the cost of the scheme is negligible. The scheme

Distributed persistent object systems provide a convenient environment for applications that need to manage complex long-lived data. Since Java has no persistence model built into it, the tremendous growth in the popularity of Java has generated a lot of interest in systems that add persistence to Java. This thesis presents the design, implementation and performance evaluation of a Java Persistent Store called JPS. JPS is an efficient distributed persistent Java system built on top of the Thor object-oriented database. JPS provides

We present a new client cache consistency algorithm for client caching database management systems. The algorithm, called Asynchronous Avoidance-based Cache Consistency (AACC), provides both good performance as well as a low abort rate. We present simulation results that compare AACC with two leading cache consistency algorithms: Adaptive Callback Locking (ACBL) and Adaptive Optimistic Concurrency Control (AOCC). Callback cache consistency (e.g. ACBL) is the most widely implemented algorithm due to its low abort rate and good performance. AOCC is an optimistic algorithm that has been shown to outperform ACBL under certain workload and system configurations. Until now one could either have high performance and high abort rate as in AOCC, or relatively lower performance but the low abort rate of ACBL. Our performance study shows that AACC outperforms both ACBL and AOCC for important workloads and system configurations. AACC has the high performance of AOCC, as well as the robustness and ...

We present a new client cache consistency al-gorithm for client caching database management systems. The algorithm, called Asynchronous Avoidance-based Cache Consistency (AACC), provides both good performance as well as a low abort rate. We present simulation results that compare AACC with two leading cache con-sistency algorithms: Adaptive Callback Lock-ing (ACBL) and Adaptive Optimistic Concur-rency Control (AOCC). Callback cache consis-tency (e.g. ACBL) is the most widely imple-mented algorithm due to its low abort rate and good performance. AOCC is an optimistic algo-rithm that has been shown to outperform ACBL under certain workload and system configura-tions. Until now one could either have high per-formance and high abort rate as in AOCC, or rela-tively lower performance but the low abort rate of ACBL. Our performance study shows that AACC outperforms both ACBL and AOCC for important workloads and system configurations. AACC has the high performance of AOCC, as well as the ro-bustness and low abort rate of ACBL. 1

Applications of the future will need to support large numbers of clients and will require scalable storage systems that allow state to be shared reliably. Recent research in distributed file systems provides technology that increases the scalability of storage systems. But file systems only support sharing with weak consistency guarantees and can not support applications that require transactional consistency. The challenge is how to provide scalable storage systems that support transactional applications. We are developing technology for scalable transactional storage systems. Our approach combines scalable caching and coherence techniques developed in serverless file systems and DSM systems, with recovery techniques developed in traditional databases. This position paper describes the design rationale for split caching, a new scalable memory management technique for network-based transactional object storage systems, and fragment reconstruction, a new coherence protocol that supports...

... of long-lived objects shared by many programs. At any point in time, the database obeys some schema. Over time, the system is likely to experience schema changes. The requirement for both good performance and sound semantics has made schema evolution a long-standing challenge. When and how to evolve existing objects to conform to a new schema is at the core of the problem. This thesis addresses this problem with both semantics analysis and an implementation. First, we