[[ Aside: users of Internet Explorer may get a free calculator
due to a security hole. See this page source and
this
description of the problem. ]]
]]>
The problem
To reclaim dead memory resources by discovering dynamically which are still `in use', and freeing those that are
not. Actions may be attached to memory resources to be performed when it is first discovered they are
free (finalization).
The notion of white/grey/black coloured pointer graph: The graph of memory resources defined by the pointers leading from
one resource (object or node) to another has to be explored by the garbage collector to discover which pieces of it are
disconnected from the wanted portion.
During this exploration, nodes in the graph as-yet-unvisited are termed "white", nodes visited but not explored from are
termed "grey", and nodes both visited and explored from are "black".
By initially making all nodes white, and then exploring those nodes connected from the root set and labelling nodes with
these notional colours, You eventually end up with live nodes labelled "black" and dead nodes (not in the region
connected to the roots) are still "white". While there are still "grey" nodes, the GC clearly still has work to do.
They denote an active fringe of work still to be done.
The dimensions of GC
conservative v. exact Consevative GC's need to function in the present of ambigous values---ones
which may be pointers or may not.
reclaiming cycles or not Simple-minded GCs can restrict themselves to a model in which the graph of nodes
contains no cycles. Such GCs are not general, but may be useful in restricted domains.
distributed or single address space The heap to be collected might be spread across a distributed memory,
or persistent store.
relocating or not Objects may be moved by the GC as it works in order to coallesce and free-up address space.
monolithic / incremental / concurrent The GC may take over the application totally until it has finished its
reclaimation, or may do a portion of work for each allocation request, or may work asynchrounously to the application.
dealing with moribund-object finalization A protocol for informing the application of objects that are about to die.
