2
2 The Essence uProgramming is easier if the run-time system “garbage-collects” --- makes space belonging to unusable data available for reuse. wJava does it; C does not. wBut stack allocation in C gets some of the advantage.

3
3 Desiderata 1.Speed --- low overhead for garbage collector. 2.Little program interruption. wMany collectors shut down the program to hunt for garbage. 3.Locality --- data that is used together is placed together on pages, cache- lines.

4
4 The Model --- (1) uThere is a root set of data that is a- priori reachable. wExample: In Java, root set = static class variables plus variables on run-time stack. uReachable data : root set plus anything referenced by something reachable. uQuestion: Why doesn’t this make sense for C? Why is it OK for Java?

5
5 The Model --- (2) uThings requiring space are “objects.” uAvailable space is in a heap --- large area managed by the run-time system. wAllocator finds space for new objects. Space for an object is a chunk. wGarbage collector finds unusable objects, returns their space to the heap, and maybe moves objects around in the heap.

6
6 A Heap... Object 1 Object 3Object 2 Free List

7
7 Taxonomy Garbage Collectors Reference- Counters Trace- Based

8
8 Reference Counting uThe simplest (but imperfect) method is to give each object a reference count = number of references to this object. wOK if objects have no internal references. uInitially, object has one reference. uIf reference count becomes 0, object is garbage and its space becomes available.

10
10 Transitive Effects uIf an object reaches RC=0 and is collected, the references within that object disappear. uFollow these references and decrement RC in the objects reached. uThat may result in more objects with RC=0, leading to recursive collection.

11
11 Example: Reference Counting Root Object A(1) E(1)D(2) B(2) C(1)

12
12 Example: Reference Counting Root Object A(0) E(1)D(2) B(2) C(1)

13
13 Example: Reference Counting Root Object E(1)D(2) B(1) C(0)

14
14 Example: Reference Counting Root Object E(1)D(1) B(1) B, D, and E are garbage, but their reference counts are all > 0. They never get collected.

16
16 Four States of Memory Chunks 1.Free = not holding an object; available for allocation. 2.Unreached = Holds an object, but has not yet been reached from the root set. 3.Unscanned = Reached from the root set, but its references not yet followed. 4.Scanned = Reached and references followed.

17
17 Marking 1.Assume all objects in Unreached state. 2.Start with the root set. Put them in state Unscanned. 3.while Unscanned objects remain do examine one of these objects; make its state be Scanned; add all referenced objects to Unscanned if they have not been there; end;

18
18 Sweeping uPlace all objects still in the Unreached state into the Free state. uPlace all objects in Scanned state into the Unreached state. wTo prepare for the next mark-and-sweep.

20
20 Baker’s Algorithm --- (1) uProblem: The basic algorithm takes time proportional to the heap size. wBecause you must visit all objects to see if they are Unreached. uBaker’s algorithm keeps a list of all allocated chucks of memory, as well as the Free list.

21
21 Baker’s Algorithm --- (2) uKey change: In the sweep, look only at the list of allocated chunks. uThose that are not marked as Scanned are garbage and are moved to the Free list. uThose in the Scanned state are put in the Unreached state. wFor the next collection.

23
23 Issue: Why Compact? uCompact = move reachable objects to contiguous memory. uLocality --- fewer pages or cache-lines needed to hold the active data. uFragmentation --- available space must be managed so there is space to store large objects.

24
24 Mark-and-Compact 1.Mark reachable objects as before. 2.Maintain a table (hash?) from reached chunks to new locations for the objects in those chunks. wScan chunks from low end of heap. wMaintain pointer free that counts how much space is used by reached objects so far.

25
25 Mark-and-Compact --- (2) 3.Move all reached objects to their new locations, and also retarget all references in those objects to the new locations. wUse the table of new locations. 4.Retarget root references.

36
36 Cheney’s Copying Collector uA shotgun approach to GC. u2 heaps: Allocate space in one, copy to second when first is full, then swap roles. uMaintain table of new locations. uAs soon as an object is reached, give it the next free chunk in the second heap. uAs you scan objects, adjust their references to point to second heap.

38
38 Short-Pause Garbage-Collection 1.Incremental --- run garbage collection in parallel with mutation (operation of the program). 2.Partial --- stop the mutation, but only briefly, to garbage collect a part of the heap.

39
39 Problem With Incremental GC uOK to mark garbage as reachable. uNot OK to GC a reachable object. uIf a reference r within a Scanned object is mutated to point to an Unreached object, the latter may be garbage- collected anyway. wSubtle point: How do you point to an Unreached object?

40
40 One Solution: Write Barriers uIntercept every write of a reference in a scanned object. uPlace the new object referred to on the Unscanned list. uA trick: protect all pages containing Scanned objects. wA hardware interrupt will invoke the fixup.

42
42 The Object Life-Cycle u“Most objects die young.” wBut those that survive one GC are likely to survive many. uTailor GC to spend more time on regions of the heap where objects have just been created. wGives a better ratio of reclaimed space per unit time.

43
43 Partial Garbage Collection uWe collect one part(ition) of the heap. wThe target set. uWe maintain for each partition a remembered set of those objects outside the partition (the stable set) that refer to objects in the target set. wWrite barriers can be used to maintain the remembered set.

44
44 Collecting a Partition uTo collect a part of the heap: 1.Add the remembered set for that partition to the root set. 2.Do a reachability analysis as before. uNote the resulting Scanned set may include garbage.

45
45 Example: “Reachable” Garbage The target partition Not reached from the root set In the remembered set Stable set

46
46 Generational Garbage Collection uDivide the heap into partitions P0, P1,… wEach partition holds older objects than the one before it. uCreate new objects in P0, until it fills up. uGarbage collect P0 only, and move the reachable objects to P1.

51
51 Organization of Heap uThere can be any number of trains, and each train can have any number of cars. wYou need to decide on a policy that gives a reasonable number of each. uNew objects can be placed in last car of last train, or start a new car or even a new train.

52
52 Garbage-Collection Steps 1.Collect the first car of the first train. 2.Collect the entire first train if there are no references from the root set or other trains. wImportant: this is how we find and eliminate large, cyclic garbage structures.

53
53 Remembered Sets uEach car has a remembered set of references from later trains and later cars of the same train. uImportant: since we only collect first cars and trains, we never need to worry about “forward” references (to later trains or later cars of the same train).

54
54 Collecting the First Car of the First Train uDo a partial collection as before, using every other car/train as the stable set. uMove all Reachable objects of the first car somewhere else. uGet rid of the car.

55
55 Moving Reachable Objects uIf object o has a reference from another train, pick one such train and move o to that train. wSame car as reference, if possible, else make new car. uIf references only from root set or first train, move o to another car of first train, or create new car.

56
56 Panic Mode uThe problem: it is possible that when collecting the first car, nothing is garbage. uWe then have to create a new car of the first train that is essentially the same as the old first car.

57
57 Panic Mode --- (2) uIf that happens, we go into panic mode, which requires that: 1.If a reference to any object in the first train is rewritten, we make the new reference a “dummy” member of the root set. 2.During GC, if we encounter a reference from the “root set,” we move the referenced object to another train.

58
58 Panic Mode --- (3) uSubtle point: If references to the first train never mutate, eventually all reachable objects will be sucked out of the first train, leaving cyclic garbage. uBut perversely, the last reference to a first-train object could move around so it is never to the first car.