Modern garbage collectors rely on read and write barriers imposed on heap accesses by the mutator, to keep track of references between different regions of the garbage collected heap, and to synchronize actions of the mutator with those of the collector. It has been a long-standing untested assumption that barriers impose significant overhead to garbage-collected applications. As a result, researchers have devoted effort to development of optimization approaches for elimination of unnecessary barriers, or proposed new algorithms for garbage collection that avoid the need for barriers while retaining the capability for independent collection of heap partitions. On the basis of the results presented here, we dispel the assumption that barrier overhead should be a primary motivator for such efforts. We present a

This paper describes Omniware, a system for producing and executing mobile code. Next generation Web applications will use mobile code to specify dynamic behavior in Web pages, implement new Web protocols and data formats, and dynamically distribute computation between servers and browsers. Like all mobile code systems, Omniware provides portability and safety. The same compiled Omniware module can be executed transparently on different machines, and a module's access to host resources can be precisely controlled. In addition to portability and safety, Omniware has two unique features. First, Omniware is open. Omniware uses software fault isolation (SFI) to enforce safe execution of standard programming languages, enabling Web developers to leverage the vast store of existing software and programming expertise. For example, Omniware developers can use C++ to create programs for Web pages. Second, Omniware is fast. We evaluated Omniware under the Solaris 2.4 operating system on a SPARCstation 5 using eight C benchmark programs, including five programs from the C SPEC92 benchmark suite. We evaluated the performance of Omniware in two ways. First, we showed that Omniware modules can be represented compactly, reducing the space consumption compared to SunPro cc shared object files by an average of 38%. Second, we showed that Omniware modules execute at near native speeds. Including the runtime overhead necessary to ensure that Omniware modules are both portable and safe, our benchmark programs ran within 6% of native performance.

ion helps programmers, including real-time programmers, deal with complexity. But real-time developers must use abstraction with discretion. They must be What is Real-Time Java? 10 Issues in the Design and Implementation of Real-Time Java able to break through layers of abstraction whenever this is necessary in order to understand or exercise control over real-time behavior. A Real-Time Java program consists of an arbitrary number of real-time activities accompanied by an arbitrary number of runnable threads. The runnable threads have no time-constrained behavior. The discussion of real-time activities provided below makes frequent reference the the real-time executive. See "The Real-Time Executive" on page 15. A Real-Time Activity A real-time activity consists of a configuration manager, an administrator, an arbitrary number of real-time tasks, and an arbitrary number of runnable threads. The point in specifying runnable threads as part of a real-time activity is to allow them to b...

We introduce a new replication-based copyi ng garbage coll ecti on technique. We haveimplementedone simplevari ati onofthis methodtoprovideincremental garbage collectiononstock hardware withnospeci al operati ng systemor virtual memory support. The perf ormance of the prototype implementati on i s excel l ent: major garbage collectionpauses are completely eliminated withonly a slight increase i n minor collectionpause ti mes. Unlikethestandard copyingalgori thm, thereplicati on-based method does not destroy theori ginal replica when a copy iscreated. Instead, multiple copies may exi st, and vari ous standard strategies formaintainingconsi stency may beapplied. In our implementati on forStandardML of NewJersey, themutator conti nues to use the from-space replicas unti l the collector has achieved a consi stent replica of all livedata i n to-space. We present a desi gn for a concurrent garbage collector usi ng thereplicati onbased technique. We also expect replicati on-based gc methods to be useful in providing servi ces f or persi stence and distri buti on, and brie y discuss these possi bilities.

In this paper we develop and evaluate a number of storage reclamation algorithms for client-server persistent object stores. Experience with a detailed simulation and a prototype implementation in the Exodus storage manager shows that one of our proposed algorithms, the Incremental Partitioned Collector, is complete, maintains transaction semantics, and can be run incrementally and concurrently with client applications. Furthermore, it can significantly improve subsequent system performance by reclustering data, rendering it attractive even for systems that choose not to support automatic storage reclamation. 1 Introduction Experience with object-oriented programming languages has demonstrated that explicit storage management by programmers is a difficult and error prone task --- anyone who has spent time trying to find a storage leak in a non-trivial C++ program can attest to that fact. Fortunately, in C++ programs the effect of a storage leak is limited to individual runs of progra...

Garbage collection is the automatic reclamation of computer storage [Knu73, Coh81, Wil92, Wil95]. While in many systems, programmers must explicitly reclaim heap memory at some point in their program by using a "free" or "dispose" statement, garbage collected systems free the programmer from this burden. In spite of its obvious attractiveness for many applications, garbage collection for real-time programs is not popular. This is largely due to the perceived cost and disruptiveness of garbage collection in general, and of incremental garbage collection in particular. Most existing "real-time" garbage collectors are not in fact usefully real-time, largely due to the use of a read barrier to trigger incremental copying of data structures being traversed by the running application. This may slow down running applications unpredictably, even though individual increments of garbage collection work are small and bounded. We have developed a hard real-time garbage collector which us...

Lazy allocation is a model for allocating objects on the execution stack of a high-level language which does not create dangling references. Our model provides safe transportation into the heap for objects that may survive the deallocation of the surrounding stack frame. Space for objects that do not survive the deallocation of the surrounding stack frame is reclaimed without additional effort when the stack is popped. Lazy allocation thus performs a first-level garbage collection, and if the language supports garbage collection of the heap, then our model can reduce the amortized cost of allocation in such a heap by filtering out the short-lived objects that can be more efficiently managed in LIFO order. A run-time mechanism called result expectation further filters out unneeded results from functions called only for their effects. In a shared-memory multi-processor environment, this filtering reduces contention for the allocation and management of global memory. Our model performs s...

Abstract not found

Many concurrent garbage collection (GC) algorithms have been devised, but few have been implemented and evaluated, particularly for the Java programming language. Sapphire is an algorithm we have devised for concurrent copying GC. Sapphire stresses minimizing the amount of time any given application thread may need to block to support the collector. In particular, Sapphire is intended to work well in the presence of a large number of application threads, on small- to medium-scale shared memory multiprocessors. A specific problem that Sapphire addresses is not stopping all threads while thread stacks are adjusted to account for copied objects (in GC parlance, the “flip ” to the new copies). Sapphire extends previous algorithms, and is most closely related to replicating copying collection, a GC technique in which

Introspection or the ability to observe one's own behavior is one of the most powerful capabilities of human intelligence; it is the basis for understanding and improvement of one's behavior and of human progress. Similarly, introspective computer systems, introduced in this thesis, examine, reason about, and change their own behavior in powerful new ways. Because the complexity of computers is rapidly increasing, yet is restricted by limited human resources, the most attractive quality of introspective computers is their ability to manage this growing complexity themselves. Self-managing computer systems would greatly expand the rational power and complexity of computer systems that can be successfully built. The main difficulty in constructing introspective computer systems is enabling the system to obtain a description of its complete behavior in a dynamic and unobtrusive way. This thesis proposes the partition of the system into two threads of control. The first thread performs the...