We classify clustering algorithms into sequence-based techniques---which transform the object net into a linear sequence---and partition-based clustering algorithms. Tsangaris and Naughton [TN91, TN92] have shown that the partition-based techniques are superior. However, their work is based on a single partitioning algorithm, the Kernighan and Lin heuristics, which is not applicable to realistically large object bases because of its high running-time complexity. The contribution of this paper is two-fold: (1) we devise a new class of greedy object graph partitioning algorithms (GGP) whose running-time complexity is moderate while still yielding good quality results. For large object graphs GGP is the best known heuristics with an acceptable running-time. (2) We carry out an extensive quantitative analysis of all well-known partitioning algorithms for clustering object graphs. Our analysis yields that no one algorithm performs superior for all object net characteristics. Therefore, we d...

When a computer system supports both paged virtual memory and large real-indexed caches, cache performance depends in part on the main memory page placement. To date, most operating systems place pages by selecting an arbitrary page frame from a pool of page frames that have been made available by the page replacement algorithm. We give a simple model that shows that this naive (arbitrary) page placement leads to up to 30 % unnecessary cache conflicts. We develop several page placement algorithms, called careful-mappmg algonthnzs, that try to select a page frame (from the pool of available page frames) that is likely to reduce cache contention. Using trace-driven simulation, we find that careful mappmg results in 1O–2OTO fewer (dynamic) cache misses than naive mapping (for a direct-mapped real-indexed multimegabyte cache). Thus, our results suggest that careful mapping by the operating system can get about half the cache miss reduction that a cache size (or associativity) doubling can.

A distributed object database stores objects persistently at servers. Applications run on client machines, fetching objects into a client-side cache of objects. If fetching and cache management are done in terms of objects, rather than fixed-size units such as pages, three problems must be solved: 1. which objects to prefetch, 2. how to translate, or swizzle, inter-object references when they are fetched from server to client, and 3. which objects to displace from the cache. This thesis reports the results of experiments to test various solutions to these problems. The experiments use the runtime system of the Thor distributed object database and benchmarks adapted from the Wisconsin OO7 benchmark suite. The thesis establishes the following points: 1. For plausible workloads involving some amount of object fetching, the prefetching policy is likely to have more impact on performance than swizzling policy or cache management policy. 2. A simple breadth-first prefetcher can have performa...

We show how to increase locality of object-oriented programs using several heaps. We introduce the notion of sandwich types which allow a coarser view on objects. Our idea for increasing locality is to use one heap per object of sandwich types. We demonstrate by performance measurements the effect of this strategy on running time, and show how to derive sandwich types from classes. Thus, it is possible to control the allocation of the different heaps using compile-time information.

Appropriate clustering of objects into pages in secondary memory is crucial to achieving good performance in a persistent object store. We present a new approach, termed semantic clustering, that exploits more of a program’s data accessing semantics than previous proposals. We insulate the source code from changes in clustering, so that clustering only impacts performance. The linguistic constructs used to specify semantic clustering are illustrated with an example of two tools with quite different access patterns. Experimentation with this example indicates that, for the tools, object sizes, and hardware configuration considered here, performing any clustering at all yields an order of magnitude improvement in overall tool execution time over pure page faulting, and that semantic clustering is faster than other forms of clustering by 20%–35%, and within 25 % of the (unattainable) optimal clustering. The most salient aspect of a tightly coupled persistent object store is that it blurs the distinction between data stored in main memory and data resident on secondary storage. Objects are accessed in a program using such an object store with little or no regard to where the object actually resides [Balch et al. 1989]. If in fact the object has not been cached in main memory, the first access to the object results in an object fault, in which the object is read in from disk and made available for access. Generally, objects

As storage interconnects evolve from single-host small-scale systems, such as traditional SCSI, to the multi-host Internet-based systems of Network-attached Secure Disks (NASD), protecting the integrity of data transfers between client and storage becomes essential. However, it is also computationally expensive and can impose significant performance penalties on storage systems. This paper explores several techniques that can protect the communications integrity of storage requests and data transfers, imposing very little performance penalty and significantly reducing the amount of required cryptography. Central to this work is an alternative cryptographic approach, called “Hash and MAC”, that reduces the cost of protecting the integrity of read traffic in storage devices that are unable to generate a message authentication code at full data transfers rates. Hash and MAC does this by precomputing security information, using and reusing the precomputed information on subsequent read requests. We also present a refined “Hash and MAC ” approach that uses incremental hash functions to improve the performance of small read and write operations as well as non-block-aligned operations.

Development of reusable software is an important software-engineering problem. Researchers address this problem by designing programming languages with features to support the development of modular software. Object-oriented languages support modularity by providing abstractions, such as Modula-3's abstract data types, that separate a software component's interface from its implementation. Some object-oriented features, however, incur runtime costs, because they shift binding time, which is the time when the complete representations of types and variables are known, from compile time to run time. Late binding makes it difficult for a compiler to implement these features efficiently. This thesis describes a software approach to the problem of implementing high-level programming languages with late binding. We show how Modula-3's and C++'s features that require late binding can be implemented more efficiently with an optimizing linker. We describe the design and implementation of m...

COOL v2 1 is an object oriented persistent computing system for distributed programming. With COOL v2 , C++ objects can be persistent and shared freely between applications and distributed across sites in a completely transparent manner from the programmer`s point of view. To address the problem of maintaining distributed shared data coherency, data persistency and address allocation coherency, we developed the persistent context space model which encapsulates distributed shared memory and persistent memory, and controls distributed shared memory address allocation. This paper outlines existing solutions of object addressing in persistent and distributed environments and contrasts these with the persistent context space model and its integration in an operating system architecture. 1 Introduction The use of the UMA 2 programming model on distributed systems has been investigated as a means to preserve programming simplicity and benefit at the same time from the increased paralleli...

This paper describes a mechanism for secondary storage garbage collection that may be used to reclaim inaccessible resources in decentralized persistent object based systems. Schemes for object addressing and object identification are discussed and a proposal is made which handles volatile objects separately from persistent objects. The garbage collection of the space of volatile objects is decoupled from the garbage collection of the space of persistent objects. The first kind of garbage collection can avoid the complexity and overhead of a distributed algorithm by classifying "exported" objects as persistent. The problem of detecting and collecting "distributed garbage" is then deferred to garbage collection of persistent objects. 1 Introduction Object Oriented programming generates large numbers of dynamically allocated objects. Many of these are used for a limited period of time and then become unreachable. To detect such "garbage" and make it available for reuse is the garbage co...

We investigate clustering techniques that are specifically tailored for object-oriented database systems. Unlike traditional database systems object-oriented data models incorporate the application behavior in the form of type-associated operations. This source of information is exploited for clustering decisions by statically determining the operations' access behavior applying dataflow analysis techniques. This process yields a set of weighted access paths. The statically extracted (syntactical) access patterns are then matched with the actual object net. Thereby the interobject reference chains that are likely being traversed in the database applications accumulate correspondingly high weights. The object net can then be viewed as a weighted graph whose nodes correspond to objects and whose edges are weighted inter-object references. We then employ a newly developed (greedy) heuristics for graph partitioning---which exhibits moderate complexity and, thus, is applicable t...