A Parallel, Real-Time GarbageCollector
Author: Perry Cheng,
Guy E. Blelloch
Presenter: Jun Tao
Outline
•Introduction
•Background and definitions
•Theoretical algorithm
•Extended algorithm
•Evaluation
•Conclusion
Introduction
•First garbage collectors:
–Non-incremental, non-parallel
•Recent collector
–Incremental
–Concurrent
–Parallel
Introduction
•Scalably parallel and real-time collector
–All aspects of the collector are incremental
–Parallel
•Arbitrary number of application and collector threads
–Tight theoretical bounds on
•Pause time for any application
•Total memory usage
–Asymptotically but not practically efficient
Introduction
•Extended collector algorithm
–Work with generations
–Increase the granularity of the incremental steps
–Separately handle global variables
–Delay the copy on write
–Reduce the synchronization cost of copying smallobjects
–Parallelize the processing of large objects
–Reduce double allocation during collection
–Allow program stacks
Background and Definitions
•A semispace Stop-Copy Collector
–Divide heap memory into two equally-sized
•From-space and to-space
–Suspend mutator and copy reachable objects tothe to-space when from-space is full
–Update root values and reversing the role of from-space and to-space
Background and Definitions
•Types of Garbage Collectors
Background and Definitions
•Type of Garbage Collector (continued)
Background and Definitions
•Real-time Collector
–Maximum pause time
–Utilization
•The fraction of time that the mutator executes
–Minimum Mutator Utilization
•A function of window size
•Minimum utilization at all windows of that size
•= 0 when window size <= maximum pause time
Theoretical Algorithm
•A Parallel, incremental and concurrent collector
–Base on Cheney’s simple copying collector
–All objects are stored in a shared global pool ofmemory
–Two atomic instruction
•FetchAndAdd
•CompareAndSwap
–Collector interfaces with the application
•Allocating space for a new object
•Initializing the fields of a new object
•Modifying the field of an existing object
Theoretical Algorithm
•Scalable Parallelism
–Maintain the set of gray objects
–Cheney’s technique
•Keeping them in contiguous locations in to-space
•Pros
–Simple
•Cons
–Restricts the traversal order to breadth-first
–Difficult to implement in a parallel setting
Theoretical Algorithm
•Scalable Parallelism (continued)
–Explicitly managed local stack
•Each processor maintains a stack
•A shared stack of gray objects
•Periodically transfer gray objects between local andshared stack
•Avoid idleness
–Pushes (or pops) can proceed in parallel
•Reserve a target region before transfer
•Pushes and pops are not concurrent
•Room sychronization
Theoretical Algorithm
•Scalable Parallelism (continued)
–Avoid white objects being copied twice
•Exclusive access by atomic instructions
•Copy-copy synchronization
Theoretical Algorithm
•Incremental and Replicating Collection
–Baker’s incremental collector
•Copy k units of data when allocate a unit of data
–Bound the pause time
•Mutator can only see copied objects in to-space
–A read barrier is needed
–Modification to avoid the read barrier
•Mutator can only see the original objects in from-space
–A write barrier is needed
Theoretical Algorithm
•Concurrency
–Program and collector execute simultaneously
–Program manipulate primary memory graph
–Collector manipulate replica graph
–A copy-write synchronization is needed
•Replica objects should be modified correspondently
•Avoid race condition
–Mark objects being copied
–Mutator’s update to replica should be delay
–A write-write synchronization is needed
•Prohibit different mutator threads from modifying thesame memory location concurrently
Theoretical Algorithm
•Space and Time Bounds
–Time bounds on each memory operation
•ck
–C : a constant
–K: the number of words we collect per word allocated
–Space bounds
•2(R(1+1.5/k)+N+5PD) ≈ 2(R(1+1.5/k)
–R: reachable space
–N: maximum object count
–P: P-way multiprocessor
–D: maximum memory graph depth
Extended Algorithm
•Globals, Stacks and Stacklets
–Globals
•Updated when collection ends
•Arbitrary many -> unbound time
•Replicate globals like other heap objects
•Every global has two location
•A single flag is used for all globals
–Stacks and Stacklets
•Divided stacks into fixed-size stacklets
•At most one stacklet is active and the other can bereplicated savely
•Also bound the waste space per stack
Extended Algorithm
•Granularity
–Block Allocation and Free Initialization
•Avoid calling FetchAndAdd for every memory allocation
•Each processor maintain a local pool in from-space anda local pool in to-space when collector is on
•Using a FetchAndAdd when allocating a local pool
–Write Barrier
•Avoid updating copied objects every time
•Record a triple <x, i, y> in a write log and defer
•Invoke the collector when the write log is full
•Eliminating frequent context switches
Extended Algorithm
•Small and Large Objects
–Original Algorithm
•One field at a time
–Reinterpretation of the tag word
–Transferring the object from and to the local stack
–Extended Algorithm
•Small objects
–Locked down and copied at a time
•Large objects
–Divided into segments
–One segment at a time
Extended Algorithm
•Algorithmic Modifications
–Reducing double allocation
•One allocation by mutator and one by collector
•Deferring the double allocation
–Rooms and Better Rooms
•A push room and a pop room
•Only one room can be non-empty
•Rooms
–Enter the pop room, fetch work and perform, transition to thepush room, push objects back to the shared stack
–Graying objects is time-consuming
–Wait for entering the push room
Extended Algorithm
•Algorithm modifications
–Rooms and Better Rooms (continued)
•Better rooms
–Leave the pop room after fetching work from shared stack
–Detect the shared stack is empty by maintaining a borrow counter
–Generational Collection
•Nursery and tenured space
•Trigger a minor collection when nursery space is full
•Trigger a major collection when tenured space is full
•Tenured references might not be modified during collection
•Hold two fields for mutable pointer
–one for mutator to use, the other for collector to update
Evaluation
Evaluation
Evaluation
Evaluation
Evaluation
Evaluation
Evaluation
Conclusion
•Implements a scalably parallel, concurrent,real-time garbage collector
•Thread synchronization is minimized