Incremental Mature Garbage Collection Using the Train Algorithm

1. Incremental Mature Garbage Collection Using the Train Algorithm By Jacob Seligmann Steffen Grarup Presented By Leon Gendler (lgendler@math.tau.ac.il)

2. Incremental Collection of Mature Objects By Richard L. Hudson J. Eliot B. Moss Incremental Mature Garbage Collection By Jacob Seligmann Steffen Grarup

3. Contents • Definitions and Traditional techniques • Train Algorithm - Basic Ideas • Example • Technical and Implementation issues • Measurement results

4. Definitions Garbage - Space occupied by data objects which can not be accessed. Root Set - Global variables, local variables in the stack and registers used by active procedures. Live Objects - The set of objects on any directed path of pointers from any member of the “root set”.

5. Garbage Collection Techniques Traditional Techniques: • Reference Counting • Mark (Sweep, Compact) • Copy

6. Problems • Undetected Cycles (Ref. Count) • Fragmentation (M-S) • Cost proportional to heap size (M-S) • Locality of references (M-C) • Extensive Paging

7. Garbage Collection Techniques • Incremental Small units of G.C. between small units of program execution. • Real-Time (Non-Disruptive). • Synchronizing the mutator with the collector • Generational “Most objects live a very short time, while a small percentage of them live much longer”

8. Train Algorithm - Definition Incrementalgarbage collection scheme for achieving non-disruptive reclamation of the oldest generational area.

9. Train Algorithm - Method Dividing mature object space into a number of fixed-sized blocks and collecting one block at each invocation.

10. Key Contribution • Recognizing and reclaiming All Garbagewhile only processing a single block at a time. • Non-Disruptive collection • Upper bound on the pause time. (fixed number of objects in one block)

11. Train Metaphor Memory Block Car Set of Blocks Train

12. Train Metaphor (cont.) • The trains are ordered by giving them sequence numbers as they are created. • Order : One block precedes another if it belongs to a lower (older) train or has a lower car numbering in the same train.

14. Intuition • Constantly clustering sets of related objects • Eventually, any linked garbage structure collapses into the same train, no matter how complex.

15. The Vision

16. Car Collection Strategy Process the lowest numbered car: 1. Check references into the car’s train if non exist, reclaim the whole train 2. Move objects referenced from outside M.O.A.(Mature Object Area) to another (older) train.

17. Car Collection Strategy (cont.) 3. Move objects to the train that references them. 4. Scan the evacuated objects for pointers to the car being collected and repeat step 3.

18. None of the objects remaining in the car are referenced form outside. Car Collection Strategy (cont.) 5. Objects referenced form further cars in the same train are moved to the last car. 6. Evacuate the car.

19. Example

26. Correctness • “Garbage Trains”- The set of trains holding a garbage structure. • As each “Garbage Train” is processed, either garbage reclaimed or moved to a higher train. • When the highest “Garbage Train” is reached, the garbage structure will be entirely in the train.

27. Fixing an Error Requirement: • All trains are eventually processed.

28. Technical Issues • Remembered set of references from outside the car pointing into the car. • Optimize by recording references only from higher numbered cars to lower numbered car.

29. Technical Issues (cont.) • “Write Barrier” - Pointer assignment run-time check. • Record pointer assignment from older to younger generations and between mature objects to other mature objects. • Train Table

30. Popular objects • Large remembered set. • Moving is expensive. • Sol. 1: Indirect addressing • Run-time overhead. • Sol. 2: Do not collect car, move to the end of the newest train. • Leaves garbage in or referenced from those cars. • Scatters garbage across several trains.

31. The Implementation The Original Mjolner BETA system: • Two generations: • I.O.A. reclaimed using Copy collector • M.O.A. reclaimed using Mark-Sweep • Arrays of pointer-less objects kept separately. • Single Remembered Set (Hash Table) for references from old to young objects • Write Barrier

32. New BETA System • Reclamation using the Train Algorithm. • 64Kb car size. • A Train Table. • Remembered set for each car: • References to young generation • References from higher cars

33. Evacuation Strategy • Objects referenced from several trains • Last car of the first encountered train • Last car of newest train (if referenced from outside M.O.A.) • Promoted objects • Last car of the newest train • Create new train if “fill limit” exceeded

34. Invocation Frequency • Incremental • must be called often enough so that storage resources are never exhausted. • Garbage Ratio • Memory size before and after a collection • Adjust collection frequency accordingly

35. Invocation Frequency (cont.) • Difficult to calculate • parts of memory are not yet processed • only small area collected at each invocation • An object counter for each train.

36. The Results • Collection pauses • Time Overhead • Young Generation Collector • Old Generation Collector • Storage Overhead

37. Collection Pauses

38. Time Overhead • Old Generation Collection • An increase of 20% in collection time. • Young Generation Collection • Roots are found in several remembered sets. • Object Promotion caused many set insertions Overall Results:Total execution time increased by 1%.

39. Storage Overhead • Car remembered set Overhead • 6-8K per car • editor: 350 entries, compiler: 700 entries • Car size - 64K • Train Table - 256K (64K entries) • One word for the train number • One for the car number

40. Storage Overhead (cont.) Overall Result: • Old generation storage overhead of 10% - 20% • Application storage overhead of 4% - 8%

41. Conclusions • Non Disruptive M.O.A. collection • Minimizes collection delays to few msc. • A very low maximum delay • A negligible increase in run time • A small increase in storage requirements