Hoping to cover Garbage Collection ! Motivation & basics
! Introduction to three families of collection algorithms: ! Reference Counting
! Mark & Sweep
Andrew Tolmach ! Copying Collection
! Advanced issues and topics
(Slides prepared by Marius Nita.)
1 2
Motivation Garbage Collection (GC)
Problems with manual memory management: ! The automatic reclamation of unreachable memory (aka garbage). ! It is extremely tedious and error-prone. ! Universally used for high level languages with closures ! It introduces software engineering issues (Who is and complex data structures that are allocated supposed to free the memory?) implicitly. ! It is by no means intrinsically efficient. (free is not free.) ! Useful for any language that supports heap allocation.
! In many cases, the costs outweigh the benefits. ! It removes the need for explicit deallocation (no more delete and free). ! Let the GC implementor deal with memory corruption issues once and for all.
3 4 How does it work? Terminology
Typically: Heap: Adirectedgraphwhosenodesaredynamically ! The user program (mutator)islinkedagainstalibrary allocated records and whose edges are pointers between known as the runtime system (RTS) (e.g. libc). nodes. Typically laid out in a contiguous memory space. ! In the RTS resides the memory allocation service,which Root set: The set of pointers into the heap from an external exposes an allocation routine to the user program. source (e.g. the stack, global variables). ! When the user program desires more memory, it Live data: The set of heap records that are reachable by invokes the allocation routine (e.g. malloc). following paths starting at members of the root set. ! The allocation service may then perform a collection to Garbage: The set of heap records that are not live. free unused memory before the allocation routine Note: reachability is a conservative liveness estimate. returns.
5 6
Simple heap model Reference counting
For simplicity, consider a simple heap of “cons cells:” Most straightforward collection strategy. two-field records, both fields are pointers to other records. ! Add a counter field to each record.
! Increment a record’s counter when taking a new pointer
GLOBALS to it. ! Decrement it when releasing a pointer to it.
! When it reaches 0,puttherecordonafreelist.
! When allocating a new record, check the free list first.
STACK HEAP
7 8 Reference counting Reference counting
! simple, easy to understand and implement ! simple, easy to understand and implement
! immediate reclamation of storage: no extended periods ! immediate reclamation of storage: no extended periods of time in which the collector might be running while the of time in which the collector might be running while the mutator waits mutator waits However,
9 9-a
Reference counting Stop & Collect
! simple, easy to understand and implement There is no need to get rid of garbage if you do not need more space. ! immediate reclamation of storage: no extended periods of time in which the collector might be running while the Abetterapproachistowaituntiltheallocatorfailstoallocate mutator waits new memory due to lack of space. Then, ! However, The collector takes over and frees enough memory to satisfy the allocation request. ! space overhead (extra field per record) ! The allocation now succeeds (or we’re out of memory). ! speed overhead (every pointer assignment is wrapped ! Control is returned to the mutator. in counter operations and checks) This is known as stop & collect;mutatoriseffectivelypaused ! too simple-minded (can’t collect cyclic garbage) while the collector runs.
9-b 10 Mark & Sweep M&S: implementation
Two phases: struct cell { int mark:1; 1. Mark each live record by tracing all pointers starting at struct cell *c[2]; }; the root. struct cell *free, heap[HEAPSIZE], *roots[ROOTS]; 2. Sweep unmarked records (garbage) onto a free list, Initially all cells are on free list. Use c[0] to link members of making them available for reuse. Unmark marked cells free list. at the same time. void init_heap() { for (i=0; i < HEAPSIZE-1; i++) Already marked records are ignored in the marking step, so heap[i].c[0] = &(heap[i+1]); termination is guaranteed. heap[HEAPSIZE-1].c[0] = 0; free = &(heap[0]); }
11 12
M&S: implementation M&S: implementation struct cell *allocate() { void gc() { void sweep() { struct cell *newCell; for (i=0; i
13 14 M&S: implementation M&S: pointer reversal void gc() { void sweep() { for (i=0; i
14-a 15
Copying collection Copying (cont’d)
ALLOCATION SPACE RESERVE SPACE ! Divide the heap into two semi-spaces. START OF CYCLE: ! Allocate into one space (the to-space). DATA ! When it fills up, move the live data to the from-space and reverse the roles of the two spaces. ALLOCATION SPACE RESERVE SPACE BEFORE COLLECTION: ! Must reassign all pointers as a consequence. (Can’t DATA & GARBAGE have a copying collector for C!) RESERVE SPACE ALLOCATION SPACE ! Inherently compacting – no fragmentation problems, good spatial locality. AFTER COLLECTION: DATA
16 17 Copying (cont’d) Copying (cont’d)
! The live data is traversed breadth-first using the to-space itself as the queue (Cheney’s algorithm).
! When a record is copied, a forwarding pointer pointing to the new location is left in the original. FROM SPACE ROOT SET TO SPACE BEFORE COLLECTION ! Subsequent attempts to forward that same record will immediately observe the forwarding pointer.
FROM SPACE ROOT SET TO SPACE AFTER COLLECTION
18 19
Copying: details Copying: implementation
GRAPH B struct cell { struct cell *allocate() { Root A struct cell *c[2]; if (free == end) { Set E } /* no room */ TO-SPACE C D gc(); (1) S = scan pointer F = free pointer struct cell space[2][HALFSIZE]; if (free == end) AB S F = copied but not scanned struct cell *roots[ROOTS]; /* still no room */ (2) struct cell *free = die(); = copied and scanned ABC (all pointers are to &(space[0][0]); }; S F to-space) struct cell *end = return free++; (3) &(space[0][HALFSIZE]); } ABCD S F (4) int from_space = 0; ACDB S F int to_space = 1; (5) ABCDE S F
20 21 Copying: implementation Copying: implementation gc() { struct cell *forward(struct cell *p) { int i; if (p >= &(space[from_space][0]) && struct cell *scan = &(space[to_space][0]); p<&(space[from_space][HALFSIZE])) free = scan; { for (i = 0 ; i < ROOTS; i++) if (p->c[0] >= &(space[to_space][0]) && roots[i] = forward(roots[i]); p->c[0] < &(space[to_space][HALFSIZE])) while (scan < free) { return p->c[0]; scan->c[0] = forward(scan->c[0]); else { scan->c[1] = forward(scan->c[1]); *free = *p; scan++; p->c[0] = free++; }; return p->c[0]; from_space = 1-from_space; } to_space = 1-to_space; } end = *(space[from_space][HALFSIZE]); else return p; } }
22 23
Conclusions: M&S Conclusions: Copying
Pros: Pros: ! Big win is that it can use the whole heap for allocation. ! Simple to understand and implement. ! Works well in systems with large amounts of live data – ! Allocation is very fast: contiguous free memory. many long lived objects. ! Good locality, favorable effect on cache behavior. Cons: Cons: ! Fragmentation is a real problem. ! It can use only half the heap space for allocation – a ! Allocation can be expensive in a heavily fragmented real concern in systems with limited memory. heap. ! Poor performance in systems with large amounts of live ! Potential spatial locality issues, bad cache behavior. data.
24 25 Further Issues
! Distinguishing pointers from integers.
! Handling records of various sizes, arrays.
! Finding and passing the root set.
! Avoiding unnecessary scanning of long-lived data.
! Minimizing collection pauses.
! Improving memory utilization. These lead to study of other varieties of collectors: conservative, generational, incremental, compacting, etc.
26