1. How to determine whether a chunk of storage is no longer accessible to the program, and
2. How to make deallocation as efficient as possible; in particular how to avoid long pauses in the program's execution when deallocation is being done.

1. Reference counting, and
2. Garbage Collection.

Reference counting

• When a pointer is copied, a new reference is created, so the reference count of the object pointed to must be incremented.
• When a non-null pointer's value is over-written, a reference is removed, so the reference count of the object pointed to (before the over-write) must be decremented. (Note that this means that pointers must be initialized to null; otherwise, the reference count of some random piece of storage -- whose address happened to be in the uninitialized pointer -- would erroneously be decremented.)

There are two important problems with reference counting:

1. Every write into a pointer requires a test to see whether the old value was null, and also requires that one or two reference counts be updated; this may slow the program down quite a bit.
2. Cyclic structures cannot be deallocated. This is illustrated by the following (Pascal) code:

          var p: Nodeptr;  /* p is a pointer to a node */
          new(p);          /* p points to newly allocated storage
                              for one node; its reference count is 1 */
          p^.next = p;     /* the next field of the node also points to the
                              node itself, so now its reference count is 2 */
          p = nil;         /* p's value is over-written, so the node's
                              reference count is decremented (from 2 to 1)
                              In fact, it is inaccessible (it points to itself,
                              no other pointer points to it), but we can't tell
                              that just from the reference count. */
          

Garbage collection

• Find all accessible objects.
• Free all other (inaccessible) objects.

1. Mark and Sweep
2. Stop and Copy

Mark and Sweep

The Mark and Sweep technique has two phases:

1. The mark phase finds and marks all accessible object.
2. The sweep phase sweeps through the heap, collecting all of the garbage (the inaccessible objects) and putting them back on the freelist.

• Initialized to 0.
• Set to 1 if the chunk is reached during the mark phase.

• Start by putting all "active" pointers on a worklist. A pointer is active if it is on the stack (anywhere on the stack, not just in the topmost activation record) or in the static-data area.
• While the worklist is non-empty, select and remove a pointer, and look at the object pointed to: If its mark bit is zero, then
  • change it to 1, and
  • put all pointers contained in that object on the worklist (note that this requires being able to recognize pointers; more on that later).
  When the mark phase has finished, all accessible objects have mark bits set to one, and all inaccessible object have mark bits set to zero.

  The sweep phase starts with an empty freelist. It looks at every chunk of storage in the heap in order (note that those chunks can be recognized because we know where the heap starts, and each chunk starts with a "size" field). If the mark bit for a chunk is 0, it means that it is inaccessible. The chunk can simply be added to the freelist, but a better idea (to reverse fragmentation) is to first check the following chunks. If there is a sequence of two or more free chunks, then they can be coalesced, and the coalesced chunk is then added to the freelist.

  If the mark bit for a chunk is 1, it means that it is accessible. Therefore, it is not added to the freelist, but its mark bit is set back to zero so that it will be processed the next time the mark-and-sweep garbage collector is started up again.

  Below is an example to illustrate the mark-and-sweep process. Assume that memory looks like this when the garbage collector is called; the numbers in the chunks are mark bits, all initially 0. Note that there is just one free chunk and that some of the (non-free) objects contain pointers.

          +---------------------------------------------+
          |       +----------------+                    |
          |       |                v                    v
    +-----|-+ +---|---+ +-------+ +-------+ +-------+ +-------+ 
    | 0   o | | 0 o   | | o  0  | | 0     | | 0     | | 0     | 
    +-------+ +-------+ +-|-----+ +-------+ +-------+ +-------+ 
       ^                  | ^                   ^
       |                  | |                   |
       +------------------+ |                   |
                            |                   |
    ptr on stack: ----------+              first-free
  
  

  Here's the situation after just the mark phase (note that all chunks reachable from the stack pointer now have mark-bits = 1):

          +---------------------------------------------+
          |       +----------------+                    |
          |       |                v                    v
    +-----|-+ +---|---+ +-------+ +-------+ +-------+ +-------+ 
    | 1   o | | 0 o   | | o  1  | | 0     | | 0     | | 1     | 
    +-------+ +-------+ +-|-----+ +-------+ +-------+ +-------+ 
       ^                  | ^                   ^
       |                  | |                   |
       +------------------+ |                   |
                            |                   |
    ptr on stack: ----------+              first-free
  
  

  Finally, here's the situation after the sweep phase has finished; the second inaccessible chunk has been coalesced with the chunk that was free all along, all inaccessible chunks are now on the freelist, and all of the mark bits have been set to 0.

          +---------------------------------------------+
          |                                             |
          |    +------------------------+               |
          |    v                        |               v
    +-----|-+ +-------+ +-------+ +-----|-----------+ +-------+ 
    | 0   o | | 0 |\| | | o  0  | | 0 | o |         | | 0     | 
    +-------+ +-------+ +-|-----+ +-----------------+ +-------+ 
       ^                  | ^      ^          
       |                  | |      |      
       |                  | |      +----------+
       +------------------+ |                 | 
                            |                 | 
    ptr on stack: ----------+              first-free
  
  

Stop and Copy

For the Stop and Copy technique, the heap is divided into two parts: "old" space and "new" space. Old space is used for allocation, and new space is used for garbage collection. There is no free list; instead, a "first-free" pointer is maintained that points to the first free location in "old" space. When a chunk of n bytes is requested, the location pointed to by the first-free pointer is returned, and the first-free pointer is incremented by n (actually, "invisible" size fields are still maintained as part of each allocated chunk, so allocating a chunk would have to include maintaining that field).

When the "old" space is full, or almost full, the stop and copy garbage collection begins. It finds all accessible objects (by following pointers from the static-data area, etc. as for the mark and sweep technique), but instead of marking them, it copies them to "new" space. Once all accessible objects have been copied, the roles of the "old" and "new" space are reversed; the first-free pointer points to the first free location in the "old" space (the location just after the last copied object).

Below are two picture to illustrate the idea. The stack is shown on the left; it contains 2 pointers to heap objects. The heap is shown on the right. Initially, it contains 6 chunks of allocated storage (labeled A - F) in the "old" space. (The first-free pointer points to the small remaining chunk of storage in the "old" space.) Chunk C itself contains a pointer (pointing to chunk D). In the second picture, the three accessible chunks have been copied to what used to be "new" space, leaving behind all garbage. The first-free pointer now points to the first free location in what used to be "new" space, and is now "old" space.

        <-------- old space --------> <-------- new space -------->

        +---------------------------------------------------------+
        | A | B | C o | D | E | F |  |                            |
        +-----------|---------------------------------------------+
                 ^  |  ^       ^  ^
 |   |           |  |  |       |  |
 | o-------------+  +--+       |  first
 |   |                         |  free
 | o---------------------------+
 |   |
 +---+
 stack


           <------ new space -------> <------- old space ------>

           +---------------------------------------------------+
           |                         | C o | D | F |           |
           +---------------------------------------------------+
                                       ^  |  ^  ^   ^
 |   |                                 |  |  |  |   |
 | o-----------------------------------+  +--+  |   first
 |   |                                          |   free
 | o--------------------------------------------+
 |   |
 +---+
 stack

The example given above is repeated below, but this time we assume that object F contains a pointer to C (as well as there being a pointer to C from the stack). The first picture shows the situation before garbage collection. The second picture shows the situation after the top-most stack pointer (the one pointing to C) has been followed; C has been copied to "new" space, a forwarding pointer has been left behind, and the stack pointer has been updated. The third picture shows the final situation after garbage collection has finished; all accessible storage has been copied, all pointers to accessible storage have been updated, and the roles of "old" and "new" space reversed.

        <-------- old space ---------> <------ new space ------>

                 +----------------+
                 |                |
                 v                |
        +-------------------------|----------------------------+
        | A | B | C o | D | E | F o | |                        |
        +-----------|------------------------------------------+
                 ^  |  ^       ^     ^
 |   |           |  |  |       |     |
 | o-------------+  +--+       |    first
 |   |                         |    free
 | o---------------------------+
 |   |
 +---+
 stack

       <--------- old space ---------> <------ new space ------>

                 +---------------+
                 |    +----------|-----+
                 v    v          |     |
        +------------------------|-------|---------------------+
        | A | B |  o | D | E | F o | | C o |                   |
        +----------|-------------------------------------------+
                   |          ^       ^^    ^
                   +----------|-------+|    |
                              |        |   first
 |   |                        |        |   free
 | o--------------------------|--------+
 |   |                        |
 | o--------------------------+
 |   |
 +---+
 stack

       <-------- new space --------> <-------- old space ------>

                                     +------------+
                                     |            |
                                     |  +--+      |
                                     v  |  v      |
        +-------------------------------|---------|--------------+
        |                           | C o | D | F o |            |
        +--------------------------------------------------------+
                                     ^         ^     ^
                                     |         |     |
                                     |         |     first
 |   |                               |         |     free
 | o---------------------------------+         |
 |   |                                         |
 | o-------------------------------------------+
 |   |
 +---+
 stack

• Allocation is cheaper (no need to search the freelist, just advanced the first-free pointer).
• The fact that there is no freelist (instead, at any moment, available storage is in one big chunk, pointed to by the first-free pointer), means that there is no problem with fragmentation, and no need to coalesce storage when it is discovered to be garbage.
• In general, stop and copy is faster than mark and sweep; this is because there is no phase that scans the entire heap; instead, it requires time proportional only to the number of accessible chunks.
• The fact that accessible storage is compacted (copied into a contiguous chunk in the "new" space) leads to better performance by the program after garbage collection; for example, having accessible objects close together may mean fewer cache misses and/or fewer page faults.

Deutsch-Bobrow deferred reference counting

Listptr tmp = L;
while (tmp != null) {
   ... do something with tmp->data ...
   tmp = tmp->next;
}

If normal reference counting is used, then before the loop (when the value in L is copied in to tmp), the reference count of the first item on the list is incremented. The assignment "tmp = tmp->next" inside the loop causes the following changes to be made on each iteration:

1. The reference count of the list item pointed to by tmp is decremented (because tmp is about to be over-written).
2. The reference count of the next item on the list is incremented (because tmp now points to it, as well as the "next" field of the previous item on the list).

To avoid this kind of extra work, deferred reference counting works as follows:

• An object's reference count reflects only the number of pointers in the heap that are pointing to it; pointers from the stack and static-data area are ignored.
• Therefore, when an object's reference count becomes zero, it is not safe to free it (since it may still be pointed to by one or more pointers from the stack/static-data area).
• Therefore, when an object's reference count becomes zero, it is not freed; instead it is put on a special "zero-count" list.
• When free space gets low, or when the zero-count list gets long, garbage collection begins; each object whose true reference count is zero is identified and freed as follows:
  1. For each pointer on the stack or in the static-data area, increment the reference count of the pointed-to object. Note that when this step is finished, all objects have their true reference counts.
  2. For each item on the zero-count list: if the reference count is still zero, then it is garbage; put it on the freelist (and decrement the reference counts of any objects that it points to, putting them at the end of the freelist if their reference counts become zero).
  3. For each pointer on the stack or in the static-data area, decrement the reference count of the pointed-to object. Note that when this step is finished, all objects are back to having their reference counts reflect only heap pointers.

• For an assignment into a program variable (i.e., an assignment into a location on the stack or in the static-data area), no code is generated to update reference counts (since references from the stack/static-data area are ignored until garbage collection starts).
• However, an assignment into a pointer on the heap must involve the overhead of reference-count manipulation.

How to identify pointers

1. Every word includes a one-bit tag (0 means "not a pointer, and 1 means "is a pointer). This has a number of consequences:
   • Values (including addresses) cannot use this bit, so the ranges of possible values are smaller than normal.
   • Operations must preserve this bit. This means that hardware support is necessary.
   • On method entry, this bit must be initialized for all local variables.
   • When a chunk of storage is allocated, this bit must be initialized for all of the fields in the allocated object.
2. Again, every word has a tag, but instead of storing the tag in the word itself, it is maintained in a separate bit-map (that includes one bit for every word in the heap, the stack, and the static-data area). In this case, no bit is "stolen" (so the range of values is not restricted, and nothing special needs to be done to make sure that operations don't clobber the special bit). However, it is still necessary to initialize the bit on method entry and on storage allocation.
3. A final possibility is to associate with each variable and each allocated object (rather than with each word) a tag telling its type (which could be implemented as an index into an array of type descriptors, maintained at runtime). While the tag would require more than a single bit, this approach might save space because only one tag is required for an entire object, rather than one bit per word.

Summary