1 / 36

David Evans cs.virginia/evans

Lecture 21: Garbage Collection. David Evans http://www.cs.virginia.edu/evans. CS201j: Engineering Software University of Virginia Computer Science. Menu. Stack and Heap Mark and Sweep Stop and Copy Reference Counting Java’s Garbage Collector. Stack and Heap Review. Heap. Stack.

Download Presentation

David Evans cs.virginia/evans

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. Lecture 21: Garbage Collection David Evans http://www.cs.virginia.edu/evans CS201j: Engineering Software University of Virginia Computer Science

  2. Menu • Stack and Heap • Mark and Sweep • Stop and Copy • Reference Counting • Java’s Garbage Collector CS 201J Fall 2003

  3. Stack and Heap Review Heap Stack public class Strings { public static void test () { StringBuffer sb = new StringBuffer ("hello"); } static public void main (String args[]) { test (); test (); } } A B sb java.lang.StringBuffer 1 “hello” 2 3 When do the stack and heap look like this? CS 201J Fall 2003

  4. Stack and Heap Review Heap Stack public class Strings { public static void test () { StringBuffer sb = new StringBuffer ("hello"); } static public void main (String args[]) { test (); test (); } } B sb java.lang.StringBuffer “hello” 2 CS 201J Fall 2003

  5. Garbage Heap Heap Stack public class Strings { public static void test () { StringBuffer sb = new StringBuffer ("hello"); } static public void main (String args[]) { while (true) test (); } } “hello” “hello” “hello” “hello” “hello” “hello” “hello” “hello” “hello” “hello” “hello” “hello” “hello” “hello” “hello” “hello” “hello” “hello” “hello” “hello” “hello” “hello” “hello” “hello” “hello” “hello” “hello” “hello” CS 201J Fall 2003

  6. Garbage Collection • System needs to reclaim storage on the heap used by garbage objects • How can it identify garbage objects? • How come we don’t need to garbage collect the stack? CS 201J Fall 2003

  7. Mark and Sweep CS 201J Fall 2003

  8. Mark and Sweep • John McCarthy, 1960 (first LISP implementation) • Start with a set of root references • Mark every object you can reach from those references • Sweep up the unmarked objects What are the root references? References on the stack. CS 201J Fall 2003

  9. public class Phylogeny { static public void main (String args[]) { SpeciesSet ss = new SpeciesSet (); … (open file for reading) while (…not end of file…) { Species current = new Species (…name from file…, …genome from file…); ss.insert (current); } } public class SpeciesSet { private Vector els; public void insert (/*@non_null@*/ Species s) { if (getIndex (s) < 0) els.add (s); } CS 201J Fall 2003

  10. “in.spc” Stack name: genome: Bottom of Stack String[]: args Phylogeny.main root: Species “Duck” els: “CATAG” ss: SpeciesSet name: genome: current: Species SpeciesSet.insert “Goat” this: SpeciesSet “CAGTG” s: Species Top of Stack name: genome: name: genome: public class Phylogeny { static public void main (String args[]) { SpeciesSet ss = new SpeciesSet (); while (…not end of file…) { Species current = new Species (…name…, …genome…); ss.insert (current); } } public class SpeciesSet { private Vector els; public void insert (/*@non_null@*/ Species s) { if (getIndex (s) < 0) els.add (s); } “Frog” “Elf” “CGATG” “CGGTG”

  11. After els.add (s)… “in.spc” Stack name: genome: Bottom of Stack String[]: args Phylogeny.main root: Species “Duck” els: “CATAG” ss: SpeciesSet name: genome: current: Species SpeciesSet.insert “Goat” this: SpeciesSet “CAGTG” s: Species Top of Stack name: genome: name: genome: public class Phylogeny { static public void main (String args[]) { SpeciesSet ss = new SpeciesSet (); while (…not end of file…) { Species current = new Species (…name…, …genome…); ss.insert (current); } } public class SpeciesSet { private Vector els; public void insert (/*@non_null@*/ Species s) { if (getIndex (s) < 0) els.add (s); } “Frog” “Elf” “CGATG” “CGGTG”

  12. SpeciesSet.insert returns… “in.spc” Stack name: genome: Bottom of Stack String[]: args Phylogeny.main root: Species “Duck” els: “CATAG” ss: SpeciesSet name: genome: current: Species SpeciesSet.insert “Goat” this: SpeciesSet “CAGTG” s: Species Top of Stack name: genome: name: genome: public class Phylogeny { static public void main (String args[]) { SpeciesSet ss = new SpeciesSet (); while (…not end of file…) { Species current = new Species (…name…, …genome…); ss.insert (current); } } public class SpeciesSet { private Vector els; public void insert (/*@non_null@*/ Species s) { if (getIndex (s) < 0) els.add (s); } “Frog” “Elf” “CGATG” “CGGTG”

  13. Finish while loop… “in.spc” Stack name: genome: Bottom of Stack String[]: args Phylogeny.main root: Species “Duck” els: “CATAG” ss: SpeciesSet name: genome: current: Species Top of Stack “Goat” “CAGTG” name: genome: name: genome: public class Phylogeny { static public void main (String args[]) { SpeciesSet ss = new SpeciesSet (); while (…not end of file…) { Species current = new Species (…name…, …genome…); ss.insert (current); } } public class SpeciesSet { private Vector els; public void insert (/*@non_null@*/ Species s) { if (getIndex (s) < 0) els.add (s); } “Frog” “Elf” “CGATG” “CGGTG”

  14. Garbage Collection “in.spc” Stack name: genome: Bottom of Stack String[]: args Phylogeny.main root: Species “Duck” els: ss: SpeciesSet “CATAG” Top of Stack name: genome: “Goat” “CAGTG” name: genome: name: genome: public class Phylogeny { static public void main (String args[]) { SpeciesSet ss = new SpeciesSet (); while (…not end of file…) { Species current = new Species (…name…, …genome…); ss.insert (current); } } public class SpeciesSet { private Vector els; public void insert (/*@non_null@*/ Species s) { if (getIndex (s) < 0) els.add (s); } “Frog” “Elf” “CGATG” “CGGTG”

  15. Garbage Collection “in.spc” Stack name: genome: Bottom of Stack String[]: args Phylogeny.main root: Species “Duck” els: ss: SpeciesSet “CATAG” Top of Stack name: genome: “Goat” Initialize Mark and Sweeper: active = all objects on stack “CAGTG” name: genome: name: genome: “Frog” “Elf” “CGATG” “CGGTG”

  16. Garbage Collection “in.spc” Stack name: genome: Bottom of Stack String[]: args Phylogeny.main root: Species “Duck” els: ss: SpeciesSet “CATAG” Top of Stack name: genome: active = all objects on stack while (!active.isEmpty ()) newactive = { } foreach (Object a in active) mark a as reachable (non-garbage) foreach (Object o that a points to) if o is not marked newactive = newactive U { o } active = newactive “Goat” “CAGTG” name: genome: name: genome: “Frog” “Elf” “CGATG” “CGGTG”

  17. Garbage Collection “in.spc” Stack name: genome: Bottom of Stack String[]: args Phylogeny.main root: Species “Duck” els: ss: SpeciesSet “CATAG” Top of Stack name: genome: active = all objects on stack while (!active.isEmpty ()) newactive = { } foreach (Object a in active) mark a as reachable (non-garbage) foreach (Object o that a points to) if o is not marked newactive = newactive U { o } active = newactive “Goat” “CAGTG” name: genome: name: genome: “Frog” “Elf” “CGATG” “CGGTG”

  18. Garbage Collection “in.spc” Stack name: genome: Bottom of Stack String[]: args Phylogeny.main root: Species “Duck” els: ss: SpeciesSet “CATAG” Top of Stack name: genome: active = all objects on stack while (!active.isEmpty ()) newactive = { } foreach (Object a in active) mark a as reachable (non-garbage) foreach (Object o that a points to) if o is not marked newactive = newactive U { o } active = newactive “Goat” “CAGTG” name: genome: name: genome: “Frog” “Elf” “CGATG” “CGGTG”

  19. Garbage Collection “in.spc” Stack name: genome: Bottom of Stack String[]: args Phylogeny.main root: Species “Duck” els: ss: SpeciesSet “CATAG” Top of Stack name: genome: active = all objects on stack while (!active.isEmpty ()) newactive = { } foreach (Object a in active) mark a as reachable (non-garbage) foreach (Object o that a points to) if o is not marked newactive = newactive U { o } active = newactive “Goat” “CAGTG” name: genome: name: genome: “Frog” “Elf” “CGATG” “CGGTG”

  20. Garbage Collection “in.spc” Stack name: genome: Bottom of Stack String[]: args Phylogeny.main root: Species “Duck” els: ss: SpeciesSet “CATAG” Top of Stack name: genome: active = all objects on stack while (!active.isEmpty ()) newactive = { } foreach (Object a in active) mark a as reachable (non-garbage) foreach (Object o that a points to) if o is not marked newactive = newactive U { o } active = newactive “Goat” “CAGTG” name: genome: name: genome: “Frog” “Elf” “CGATG” “CGGTG”

  21. Garbage Collection “in.spc” Stack name: genome: Bottom of Stack String[]: args Phylogeny.main root: Species “Duck” els: ss: SpeciesSet “CATAG” Top of Stack name: genome: active = all objects on stack while (!active.isEmpty ()) newactive = { } foreach (Object a in active) mark a as reachable foreach (Object o that a points to) if o is not marked newactive = newactive U { o } active = newactive sweep () // remove unmarked objects on heap “Goat” “CAGTG” name: genome: name: genome: “Frog” “Elf” “CGATG” “CGGTG”

  22. After main returns… “in.spc” Stack name: genome: Bottom of Stack String[]: args Phylogeny.main root: Species “Duck” els: ss: SpeciesSet “CATAG” Top of Stack name: genome: active = all objects on stack while (!active.isEmpty ()) newactive = { } foreach (Object a in active) mark a as reachable foreach (Object o that a points to) if o is not marked newactive = newactive U { o } active = newactive sweep () // remove unmarked objects on heap “Goat” “CAGTG” name: genome: name: genome: “Frog” “Elf” “CGATG” “CGGTG”

  23. Garbage Collection “in.spc” Stack name: genome: Bottom of Stack Top of Stack “Duck” els: “CATAG” name: genome: active = all objects on stack while (!active.isEmpty ()) newactive = { } foreach (Object a in active) mark a as reachable foreach (Object o that a points to) if o is not marked newactive = newactive U { o } active = newactive sweep () // remove unmarked objects on heap “Goat” “CAGTG” name: genome: name: genome: “Frog” “Elf” “CGATG” “CGGTG”

  24. Problems with Mark and Sweep • Fragmentation: free space and alive objects will be mixed • Harder to allocate space for new objects • Poor locality means bad memory performance • Caches make it quick to load nearby memory • Multiple Threads • One stack per thread, one heap shared by all threads • All threads must stop for garbage collection CS 201J Fall 2003

  25. Stop and Copy • Solves fragmentation problem • Copy all reachable objects to a new memory area • After copying, reclaim the whole old heap • Disadvantages: • More complicated: need to change stack and internal object pointers to new heap • Need to save enough memory to copy • Expensive if most objects are not garbage CS 201J Fall 2003

  26. Generational Collectors • Observation: • Many objects are short-lived • Temporary objects that get garbage collected right away • Other objects are long-lived • Data that lives for the duration of execution • Separate storage into regions • Short term: collect frequently • Long term: collect infrequently • Stop and copy, but move copies into longer-lived areas CS 201J Fall 2003

  27. Reference Counting What if each object kept track of the number of references to it? If the object has zero references, it is garbage! CS 201J Fall 2003

  28. Referencing Counting T x = new T (); The x object has one reference y = x; The object x references has 1 more ref The object ypre references has 1 less ref } Leave scope where x is declared The object x references has 1 less ref CS 201J Fall 2003

  29. Reference Counting class Recycle { private String name; private Vector pals; public Recycle (String name) { this.name = name; pals = new Vector (); } public void addPal (Recycle r) { pals.addElement (r); } } public class Garbage { static public void main (String args[]) { Recycle alice = new Recycle ("alice"); Recycle bob = new Recycle ("bob"); bob.addPal (alice); alice = new Recycle ("coleen"); bob = new Recycle ("dave"); } } “Alice” name: pals: refs: 1 2 “Bob” name: pals: refs: 1 CS 201J Fall 2003

  30. Reference Counting class Recycle { private String name; private Vector pals; public Recycle (String name) { this.name = name; pals = new Vector (); } public void addPal (Recycle r) { pals.addElement (r); } } public class Garbage { static public void main (String args[]) { Recycle alice = new Recycle ("alice"); Recycle bob = new Recycle ("bob"); bob.addPal (alice); alice = new Recycle ("coleen"); bob = new Recycle ("dave"); } } “Alice” name: pals: refs: 1 2 “Coleen” “Bob” name: pals: refs: name: pals: refs: 1 1 CS 201J Fall 2003

  31. Reference Counting class Recycle { private String name; private Vector pals; public Recycle (String name) { this.name = name; pals = new Vector (); } public void addPal (Recycle r) { pals.addElement (r); } } public class Garbage { static public void main (String args[]) { Recycle alice = new Recycle ("alice"); Recycle bob = new Recycle ("bob"); bob.addPal (alice); alice = new Recycle ("coleen"); bob = new Recycle ("dave"); } } “Alice” name: pals: refs: 1 0 “Bob” name: pals: refs: 0 1 CS 201J Fall 2003

  32. Circular References class Recycle { private String name; private Vector pals; public Recycle (String name) { this.name = name; pals = new Vector (); } public void addPal (Recycle r) { pals.addElement (r); } } public class Garbage { static public void main (String args[]) { Recycle alice = new Recycle ("alice"); Recycle bob = new Recycle ("bob"); bob.addPal (alice); alice.addPal (bob); alice = null; bob = null; } } “Alice” name: pals: refs: 1 2 “Bob” name: pals: refs: 1 2 CS 201J Fall 2003

  33. Reference Counting Summary • Advantages • Can clean up garbage right away when the last reference is lost • No need to stop other threads! • Disadvantages • Need to store and maintain reference count • Some garbage is left to fester (circular references) • Memory fragmentation CS 201J Fall 2003

  34. Java’s Garbage Collector • Mark and Sweep collector • Before collecting an object, it will call finalize • Can call garbage collector directly: System.gc () protected void finalize() throws Throwable CS 201J Fall 2003

  35. Garbage in, Garbage out? class Recycle { private String name; private Vector pals; public Recycle (String name) { this.name = name; pals = new Vector (); } public void addPal (Recycle r) { pals.addElement (r); } protected void finalize () { System.err.println (name + " is garbage!"); } } public class Garbage { static public void main (String args[]) { Recycle alice = new Recycle ("alice"); Recycle bob = new Recycle ("bob"); bob.addPal (alice); alice = new Recycle ("coleen"); System.gc (); bob = new Recycle ("dave"); System.gc (); } } > java Garbage First collection: Second collection: alice is garbage! bob is garbage! CS 201J Fall 2003

  36. Charge • In Java: be happy you have a garbage collector to clean up for you • In C/C++: need to deallocate storage explicitly • Why is it hard to write a garbage collector for C? • In the real world: clean up after yourself and others! Garbage Collectors (COAX, Seoul, 18 June 2002) CS 201J Fall 2003

More Related