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

2. Incremental Mature Garbage Collection By Jacob SeligmannSteffen Grarup Incremental Collection of Mature Objects By Richard L. HudsonJ. Eliot B. Moss

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 Incremental Incremental garbage collection scheme for non-disruptive achieving non-disruptive reclamation of the oldest generational oldest generational area.

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

10. Key Contribution All Garbage Recognizing and reclaiming All Garbage while 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 BlockCar Set of BlocksTrain

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 M.O.A 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. Car Collection Strategy (cont.) 5.Objects referenced form further cars in the same train are moved to the last car. 6.Evacuate the car. None of the objects remaining in the car are referenced form outside.

19. Example

26. The Next Generation Promote young objects into any train except the one being collected. Create new trains if necessary.

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

28. Fixing an Error Requirement Requirement: All trains are eventually processed.

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

30. Technical Issues (cont.) “Write Barrier” - “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

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

32. The Implementation The Original Mjolner BETA system: Two generations: –I.O.A. –I.O.A. reclaimed using Copy collector –M.O.A. –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

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

34. Evacuation Strategy Objects referenced from several trains –Last car of the first encountered train M.O.A. –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

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

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

37. The Results Collection pauses Time Overhead –Young Generation Collector –Old Generation Collector Storage Overhead

38. Collection Pauses

39. 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%.

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

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

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