Uniprocessor Garbage Collection Techniques

1
Uniprocessor Garbage Collection Techniques

• Paul R. Wilson

2
FromSapce/Tospace before
3
Ft after
4
Too much
5
3mb vs. 6mb
6
(No Transcript)
7
The Two-Phase Abstraction

• 1. Detection
• 2. Reclamation

8
Why Garbage Collect at All?

• Safety
• Memory leaks
• Continued use of freed pointers
• Simplicity

9
Why Garbage Collect at All?

• Flexibility
• Hard coded program limits
• Efficiency!
• Who is responsible for deletion?
• Extraneous copies

10
Liveness and Garbage

• There is a root set which is defined as live.
• Anything reachable from a live pointer is also
  live
• Everything else is garbage

11
The Root Set

• The Root Set
• Static global and module variables
• Local Variables
• Variables on any activation stack(s)
• Everyone else
• Anything Reachable From a live value

12
Reference Counting Advantages

• Implicitly distributes garbage collection
• Real Time guarantees with deferred reclamation
• Keep a list of zeroed objects not yet processed
• Memory efficiency, can utilize all available
  memory with no work room

13
Reference Counting Pitfalls

• Conservative- needs a separate GC technique to
  reclaim cycles
• Expensive- pointer reassignment requires
• Increment
• Decrement
• Zero Check
• Stack Variables frequent creation/destruction
• Can be optimized to some extent

14
Reference Counting
15
Ref counting, unreclaimable
16
Deferred Reference Counting

• Defer deletion of zero counted objects
• Periodically scan the stack for pointers

17
Mark-Sweep Collection

• Starting From the root set traverse all pointers
  via depth/breadth first search.
• Free everything that is not marked.

18
Non-Copying issues

• Same as for traditional allocators
• Fragmentation
• Memory block size management
• Locality of reference- interleaved new/old
• General issues- work proportional to heap size

19
Copying Advantages

• Memory locality preserved
• Disadvantages
• Lots of copying!
• Scavenging

20

• Stop and Copy
• How to update multiple pointers to the same
  object?
• Forwarding Pointers
• Mark/Sweep is proportional to the amount of live
  data. Assuming this stays roughly constant,
  increasing memeory will increase efficiency.

21
Non Copying Version

• Facts
• Allocated with a color
• Fragmentation
• Advantages
• Does not require pointer rewriting
• Supports obscure pointer formats, C friendly

22
In place collection

• Conservative estimates
• Useful for languages like C
• Pointers can be safely passed to foreign
  libraries not written with Garbage Collection in
  mind

23
Incremental Tracing Collectors

• The Mutator
• The reachability graph may change
• From the garbage collectors point of view the
  actual application is merely a coroutine ir
  cuncurrent process with an unfortunate tendency
  to modify data structures that the collector is
  trying to traverse
• Floating Garbage
• Cant survive more than one extra round

24
Real Time Garbage Collection

• Incremental Tracing Collectors
• In Place Collection
• Many readers single writer(mutator)
• As a Copying Collector
• Multiple Readers Multiple Writers

25
Tricolor Marking

• White
• Initial color for an object subject to collection
• Black
• Objects that will be retained after the current
  round
• gray
• Object has been reached, but not its descendents
• Wave front effect

26
A violation of the Coloring Invariant
27
(No Transcript)
28
Read Barrier

• Detects an attempt to read a white object and
  immediately colors it gray

29
Write Barrier

• Traps attempts to write a pointer into an object

30
Some algorithms

• Snapshot-at-beginning write barrier
• Black-only read barrier
• Bakers read barrier
• Dijkstras write Barrier
• Steeles write Barrier

31
Bakers Read Barrier

• Allocates Black
• Grey Objects cannot be reverted to white
• Immediately Invalidates fromspace
• Any pointer access to fromspace causes the GC to
  grey the target object by copying it to tospace
  if necessary and updating the pointer.

32
Bakers Non Copying Scheme

• Real Time Friendly

33
Treadmill
34
Black Only Read Barrier

• When a white object in fromspace is touched it is
  scanned completely.

35
Replication Copying Collection

• Until copying from from space to to space is
  completed, the mutator continues to read from
  from space.
• Write updates must be trapped to update tospace.
• Single simultaneous flip where all pointers are
  updated.
• Expensive for standard hardware, but cheap for
  functional languages

36
Real time considerations

• Read Barriers add an unpredictable cost per
  pointer access
• Nilson background scavenger, reserve only
• Write barrier may be more expensive overall, but
  the cost per access is well bounded
• Guaranteeing progress allocation clock, frees per
  allocation
• Statically allocate troublesome objects

37
Results

• Writer barrier more efficient on standard
  hardware

38
Snapshot at the Beginning

• Catches pointers which try to escape from white
  objects
• If a pointer is replace in a black object, the
  replaced pointer is first stored. All overwritten
  pointers are saved via a write barrier.
• All objects that are live at the beginning of
  collection remain live
• Allocate Black during collection round
• Incremental Update
• Reverts black to gray when an object is written
  to, or else grays they new pointed to object

39
Incremental Update with Write-Barrier(Dijkstra)g

• Catches pointers that try to hide in black
  objects
• Reverts Black to gray
• If the overwritten pointer is not pointed to
  elsewhere then it is garbage
• Allocated white. Newly allocated objects assumed
  unreachable

40
Motivation for a new Strategy

• Most objects are short lived
• 80 to 90 die within a few million instructions
• Objects that dont die quickly are more likely to
  live a while
• Long lived objects are copied over and over
• Excessive Paging in Scanning if the heap must
  exceed available physical memory

41
Generational Garbage Collection
42
Generational gc before
43
Generational gc after
44
Gc memory usage
45
Variations of generational collection

• Intergenerational references
• Write barrier
• Old to younger
• Young to old
• Collection
• Advancement policies
• Advance always
• Advance after 2 rounds
• Counter in the header field?
• Advance always? Semispace in the last generation
• 3 spaces
• Bucket brigade
• Mark compact in the oldest generation for memory
  efficiency