1 / 28

A Real-Time Garbage Collector Based on the Lifetimes of Objects

A Real-Time Garbage Collector Based on the Lifetimes of Objects. Henry Lieberman and Carl Hewitt (CACM, June 1983) Rudy Kaplan Depena CS395T: Memory Management February 2, 2009. Motivation: Internal Thinking. “Programs Do A Lot of Internal Thinking” - Lieberman and Hewitt

jimbo
Download Presentation

A Real-Time Garbage Collector Based on the Lifetimes of Objects

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. A Real-Time Garbage Collector Based on the Lifetimes of Objects Henry Lieberman and Carl Hewitt (CACM, June 1983) Rudy Kaplan Depena CS395T: Memory Management February 2, 2009

  2. Motivation: Internal Thinking “Programs Do A Lot of Internal Thinking” - Lieberman and Hewitt public void printAll(ArrayList list){ Iterator it = new list.iterator(); Object temp; while( it.hasNext() ){ temp = it.next(); System.out.println( temp ); } } Code snippet from Mike Scott’s lecture on Iterators [http://www.cs.utexas.edu/~scottm/cs307/handouts/Slides/Topic15Iterators.pdf]

  3. head Node Node Node next next next refCount = 2 refCount = 1 refCount = 1 Motivation: Reference Counting Reference Counting claims young objects quickly Example from “Data Structures and Algorithms with Object-Oriented Design Patterns in Java” [http://www.brpreiss.com/books/opus5/html/page423.html]

  4. head Node Node Node next next next refCount = 1 refCount = 1 refCount = 1 Motivation: Ref Counting w/ Cycles Houston We Have A Problem! Example from “Data Structures and Algorithms with Object-Oriented Design Patterns in Java” [http://www.brpreiss.com/books/opus5/html/page423.html]

  5. Motivation: Cycles Are Needed • But Circular Structures are important programming technique for …. • Graphics • Compilers • Other Problem Spaces So What Do We Do???

  6. Real Time GC [Baker’s Algorithm] Graphics from Lieberman and Hewitt [“A Real-Time Garbage Collector Based on the Lifetimes of Objects” - CACM June 1983]

  7. What’s Wrong With Baker? • Perhaps Too Slow? • Total Garbage Collection Time? • Not Space Efficient?

  8. Generational Hypothesis • “Recently created regions contain high % of garbage” while older regions do not - Lieberman and Hewitt • Improve Baker’s Algorithm • Optimize for scavenging short lived objects • Scavenge long-lived objects less frequently • Rental Cost • Storage management cost of an object is proportional to the time during which the object is used Inspired by Maria Jump’s Presentation in Fall 2003 on Generational GC [http://www.cs.utexas.edu/users/mckinley/395Tmm-2003/talks/LH83.pdf]

  9. Modify Baker’s Algorithm • Address space broken up into generations • Small set of pages (relative to address space) • Parallels between Baker Algo and Generational GC • Evacuating <=> Condemning Region • fromspace <=> Obsolete Region • tospace <=> Non-Obsolete Region • Evacuating objects the same way Inspired by Maria Jump’s Presentation in Fall 2003 on Generational GC [http://www.cs.utexas.edu/users/mckinley/395Tmm-2003/talks/LH83.pdf]

  10. In Action 1960.0 Regions are tagged with generation and version number From Maria Jump’s Presentation in Fall 2003 on Generational GC [http://www.cs.utexas.edu/users/mckinley/395Tmm-2003/talks/LH83.pdf]

  11. In Action 1960.0 Allocation occurs in creation region From Maria Jump’s Presentation in Fall 2003 on Generational GC [http://www.cs.utexas.edu/users/mckinley/395Tmm-2003/talks/LH83.pdf]

  12. In Action 1960.0 … until the creation region is full From Maria Jump’s Presentation in Fall 2003 on Generational GC [http://www.cs.utexas.edu/users/mckinley/395Tmm-2003/talks/LH83.pdf]

  13. In Action 1970.0 1960.0 • CONS composes existing components into objects • creates a backward pointer … the new creation region is created From Maria Jump’s Presentation in Fall 2003 on Generational GC [http://www.cs.utexas.edu/users/mckinley/395Tmm-2003/talks/LH83.pdf]

  14. In Action 1970.0 1960.0 … and so on From Maria Jump’s Presentation in Fall 2003 on Generational GC [http://www.cs.utexas.edu/users/mckinley/395Tmm-2003/talks/LH83.pdf]

  15. In Action 1970.0 1980.0 1960.0 … and so on From Maria Jump’s Presentation in Fall 2003 on Generational GC [http://www.cs.utexas.edu/users/mckinley/395Tmm-2003/talks/LH83.pdf]

  16. In Action 1970.0 1980.0 1960.0 1970.1 GC is initiated by condemning a region (making it obsolete) and creating an evacuation region From Maria Jump’s Presentation in Fall 2003 on Generational GC [http://www.cs.utexas.edu/users/mckinley/395Tmm-2003/talks/LH83.pdf]

  17. In Action 1970.0 1980.0 1960.0 1970.1 1980.1 This requires that younger generations also be condemned WHY ????? Modified from Maria Jump’s Presentation in Fall 2003 on Generational GC [http://www.cs.utexas.edu/users/mckinley/395Tmm-2003/talks/LH83.pdf]

  18. In Action 1970.0 1980.0 1960.0 1970.1 1980.1 Accessibile objects in condemned region(s) are incrementally evacuated using Baker’s Algorithm From Maria Jump’s Presentation in Fall 2003 on Generational GC [http://www.cs.utexas.edu/users/mckinley/395Tmm-2003/talks/LH83.pdf]

  19. In Action 1960.0 1970.1 1980.1 … and the memory is recycled! From Maria Jump’s Presentation in Fall 2003 on Generational GC [http://www.cs.utexas.edu/users/mckinley/395Tmm-2003/talks/LH83.pdf]

  20. Varying GC Rates • Younger generations contain high percentages of garbage • They should be collected frequently • Older generation contains relatively permanent data • Older objects collected seldomly • Getting the most “Bang for your Buck” • Scavange where there is high proportion of inaccessible objects • Minimize amount of scavenging needed per inaccessible object • Why is this important? Modified from Maria Jump’s Presentation in Fall 2003 on Generational GC [http://www.cs.utexas.edu/users/mckinley/395Tmm-2003/talks/LH83.pdf]

  21. Scavanging is Expensive! • We must restrict the storage that has to be scanned to find and update obsolete references • We restrict pointers from older generations to newer generations • This means it will be faster to reclaim regions in recent generations since little storage needs to be scavenged What happens when an attempt is made to create a pointer from older to younger generation????

  22. Entry Tables 1970.0 1980.0 1960.0 • In Lisp, RPLACA can assign a new pointer as a component to an older object • creates a forward pointer • Add entry table to record forward pointers • Adds a level of indirection for some pointers • Won’t have to scan entire heap • GC uses entry table entries as roots to the region From Maria Jump’s Presentation in Fall 2003 on Generational GC [http://www.cs.utexas.edu/users/mckinley/395Tmm-2003/talks/LH83.pdf]

  23. Weak Pointers • Weak pointers are … • Pointers in program which do not protect objects from being collected. • Small in Number • Use entry table • Weak Pointers => Forward Pointers • Forward Pointers > Weak Pointers • Weak Pointers are not persistently updated if object (i.e. - pointee) is garbage collected. • Forward Pointers (which are NOT weak pointers) are persistently updated after GC occurs

  24. Some Bad News • Fragmentation results from partially filled regions …. How do we deal with this ??? • Choose region sizes to minimize fragmentation • Coalesce older regions reducing the amount of wasted space • Perhaps use hybrid incremental collection sparingly

  25. An Optimization? -Value Cells & Stacks • Lisp implementations involve internal stacks • Holds state info and variables • Stack must be scavenged for pointers to non-user-accessible objects • Young objects lifetime correlated with pushing and popping the stack. • Suggests that good time to expect a lot of garbage when returning from function (remember printAll()?)

  26. An Optimization?-Flavors of new • Providing different allocators for different regions? • Can users direct the flavor of allocation? • Can compiler analysis change flavor of allocation? • Can runtime information change flavor of allocation? From Maria Jump’s Presentation in Fall 2003 on Generational GC [http://www.cs.utexas.edu/users/mckinley/395Tmm-2003/talks/LH83.pdf]

  27. Aspects of Program Behavior • Rate of object creation • How fast are objects created? • Average lifetimes of objects • How fast do objects become inaccessible • Proportion of forward vs backward pointers • High % of pointing to old objects bodes well for this scheme • Average “length” of pointers • What’s the locality like? • Close locality would be nice :) Modified from Maria Jump’s Presentation in Fall 2003 on Generational GC [http://www.cs.utexas.edu/users/mckinley/395Tmm-2003/talks/LH83.pdf]

  28. System.out.println(“The End!”);

More Related