A Parallel, Real-Time Garbage Collector

1. A Parallel, Real-Time Garbage Collector Author: Perry Cheng, Guy E. Blelloch Presenter: Jun Tao

2. Outline • Introduction • Background and definitions • Theoretical algorithm • Extended algorithm • Evaluation • Conclusion

3. Introduction • First garbage collectors: • Non-incremental, non-parallel • Recent collector • Incremental • Concurrent • Parallel

4. 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

5. 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 small objects • Parallelize the processing of large objects • Reduce double allocation during collection • Allow program stacks

6. 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 to the to-space when from-space is full • Update root values and reversing the role of from-space and to-space

7. Background and Definitions • Types of Garbage Collectors

8. Background and Definitions • Type of Garbage Collector (continued)

9. 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

10. Theoretical Algorithm • A Parallel, incremental and concurrent collector • Base on Cheney’s simple copying collector • All objects are stored in a shared global pool of memory • 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

11. 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

12. 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 and shared stack • Avoid idleness • Pushes (or pops) can proceed in parallel • Reserve a target region before transfer • Pushes and pops are not concurrent • Room sychronization

13. Theoretical Algorithm • Scalable Parallelism (continued) • Avoid white objects being copied twice • Exclusive access by atomic instructions • Copy-copy synchronization

14. 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

15. 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 the same memory location concurrently

16. 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

17. 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 be replicated savely • Also bound the waste space per stack

18. Extended Algorithm • Granularity • Block Allocation and Free Initialization • Avoid calling FetchAndAdd for every memory allocation • Each processor maintain a local pool in from-space and a 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

19. 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

20. 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 the push room, push objects back to the shared stack • Graying objects is time-consuming • Wait for entering the push room

21. 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

22. Evaluation

23. Evaluation

24. Evaluation

25. Evaluation

26. Evaluation

27. Evaluation

28. Evaluation

29. Conclusion • Implements a scalably parallel, concurrent, real-time garbage collector • Thread synchronization is minimized