Abstract

Sapphire: Copying GC Without Stopping the World
Richard Hudson - Intel Corporation Eliot Moss - University of Massachusetts at Amherst
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 application threads observe and update primarily the old copies of objects \cite{nett92}. The key innovations of Sapphire are: (1) the ability to ``flip'' one thread at a time (changing the thread's view from the old copies of objects to the new copies), as opposed to needing to stop all threads and flip them at the same time; and (2) avoiding a read barrier.

Sapphire: Copying GC Without Stopping the World

Richard Hudson - Intel Corporation
Eliot Moss - University of Massachusetts at Amherst

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 application threads
observe and update primarily the old copies of objects \cite{nett92}. The
key
innovations of Sapphire are: (1) the ability to ``flip'' one thread at a
time
(changing the thread's view from the old copies of objects to the new
copies),
as opposed to needing to stop all threads and flip them at the same time;
and
(2) avoiding a read barrier.