mkirchner / gc, Hacker News

************************************************************************ Basic Concepts
The fundamental idea behind garbage collection is to automate the memory allocation / deallocation cycle. This is accomplished by keeping track of all allocated memory and periodically triggering deallocation for memory that is still allocated but  unreachable (************.
Many advanced garbage collectors also implement their own approach to memory allocation (i.e. replacemalloc ()). This often enables them to layout memory in a more space-efficient manner or for faster access but comes at the price of architecture-specific implementations and increased complexity.gcsidesteps these issues by falling back on the POSIX* alloc ()implementations and keeping memory management and garbage collection metadata separate. This makesgcmuch simpler to understand but, of course, also less space- and time-efficient than more optimized approaches.**********************************************************Data Structures
The core data structure insidegcis a hash map that maps the address of allocated memory to the garbage collection metadata of that memory:
The items in the hash map are allocations, modeles with theAllocationstruct:
(typedef) ******************************************************  (struct) **************************************************** Allocation {      (void)  * ptr;//  (mem pointer) *****************************************************      (size_t)  size;//  allocated size in bytes       (char)  tag;//  the tag for mark-and-sweep       (void) ******************************************************  dtor) ( (void)  *);//  (destructor) ****************************************************      (struct)  Allocation * next;//  (separate chaining) ************************************************** } Allocation;
EachAllocationinstance holds a pointer to the allocated memory, the size of the allocated memory at that location, a tag for mark-and-sweep (see below), an optional pointer to the destructor function and a pointer to the nextAllocationinstance (for separate chaining, see below).
The allocations are collected in anAllocationMap
(typedef) ******************************************************  (struct) **************************************************** AllocationMap {      (size_t)  capacity;      (size_t)  min_capacity;      (double)  downsize_factor;      (double)  upsize_factor;      (double)  sweep_factor;      (size_t)  sweep_limit;      (size_t)  size;     Allocation ** allocs; } AllocationMap;
that, together with a set ofstaticfunctions insidegc.c, provides hash map semantics for the implementation of the public API.
TheAllocationMapis the central data structure in theGarbageCollectorstruct which is part of the public API:
(typedef) ******************************************************  (struct) **************************************************** GarbageCollector {      (struct)  AllocationMap * allocs;      (bool)  paused;      (void)  * bos;      (size_t)  min_size; } GarbageCollector;
With the basic data structures in place, anygc_ * alloc ()memory allocation request is a two-step procedure: first, allocate the memory through system (i.e. standardmalloc ()functionality and second, add or update the associated metadata to the hash map.
Forgc_free (), use the pointer to locate the metadata in the hash map, determine if the deallocation requires a destructor call, call if required, free the managed memory and delete the metadata entry from the hash map.
These data structures and the associated interfaces enable the management of the metadata required to build a garbage collector.**********************************************Garbage collection
gctriggers collection under two circumstances: (a) when any of the calls to the system allocation fail (in the hope to deallocate sufficient memory to fulfill the current request); and (b) when the number of entries in the hash map passes a dynamically adjusted high water mark.
If either of these cases occurs,gcstops the world and starts a mark-and-sweep garbage collection run over all current allocations. This functionality is implemented in thegc_run ()function which is part of the public API and delegates all work to thegc_mark ()andgc_sweep ()functions that are part of the private API.
gc_mark ()has the task of  finding rootsand tagging all known allocations that are referenced from a root (or from an allocation that is referenced from a root, i.e. transitively) as "used". Once the marking of is completed,gc_sweep ()iterates over all known allocations and deallocates all unused (i.e. unmarked) allocations, returns togc_run ()and the world continues to run.
**********************************************Reachability
gcwill keep memory allocations that are  (reachable)  and collect everything else. An allocation is considered reachable if any of the following is true:
(There is a  a pointer on the stack that points to the allocation content. The pointer must reside in a stack frame that is at least as deep in the call stack as the bottom-of-stack variable passed togc_start ()(iebosis the smallest stack address considered during the mark phase).
There is a pointer insidegc_ * alloc ()- allocated content that points to the allocation content.
The allocation is tagged withGC_TAG_ROOT.
************************The Mark-and- Sweep Algorithm
The naïve mark-and-sweep algorithm runs in two stages. First, in a  (mark) ******************************************************** stage, the algorithm finds and marks all  (root) ******************************************************** allocations and all allocations that are reachable from the roots. Second, in the  (sweep) ******************************************************** stage, the algorithm passes over all known allocations, collecting all allocations that were not marked and are therefore deemed unreachable.*********************************************************************** Finding roots
At the beginning of the  (mark)  stage, we first sweep across all known allocations and find explicit roots with theGC_TAG_ROOTtag set. Each of these roots is a starting point fordepth-first recursive marking.
gcsubsequently detects all roots in the stack (starting from the bottom-of-stack pointerbosthat is passed togc_start ()) and the registers (bydumping them on the stackprior to the mark phase) and Uses these as starting points for marking as well.
********************************************************************Depth-first recursive marking
Given a root allocation, marking consists of (1) setting thetagfield in anAllocationobject toGC_TAG_MARKand (2) scanning the allocated memory for pointers to known allocations, recursively repeating the process.
The underlying implementation is a simple, recursive depth-first search that scans over all memory content to find potential references:
(void) **************************************************  (gc_mark_alloc) **************************************************** (GarbageCollector * gc,**************************************** (void)  * ptr) {     Allocation * alloc=(gc_allocation_map_get) ****************************************************** (gc ->************************ (allocs) ******************************************************, ptr);      (if) **************************************************** (alloc &&! (alloc ->************************ (tag) **************************************************** & GC_TAG_MARK)) {         alloc ->(tag)  |=GC_TAG_MARK;          (for  (*************** (char) ***************************************************** p=( (char*) alloc ->(ptr) ;              p (ptr) ****************************************************   alloc ->(size) *****************************************************;                 p) {             gc_mark_alloc  (gc, * (******************** (void)  **) p);         }     } }
Ingc.c,gc_mark ()starts the marking process by marking the known roots on the stack via a call togc_mark_roots (). To mark the roots we do one full pass through all known allocations. We then proceed to dump the registers on the stack.******************************************************************Dumping registers on the stack
In order to make the CPU register contents available for root finding,gcdumps them on the stack. This is implemented in a somewhat portable way usingsetjmp (), which stores them in ajmp_bufvariable right before we mark the stack:
.../ *  Dump registers onto stack and scan the stack
* / (void) ******************************************************  (************************************************** (volatile) ***************************************************** _mark_stack) (GarbageCollector=gc_mark_stack;  (jmp_buf)  ctx;  (memset) ****************************************************** (& ctx,***************** (0) ,  (sizeof) *****************************************************  (jmp_buf) ));  (setjmp)  (ctx);_ mark_stack(gc); ...
The detour using thevolatilefunction pointer_ mark_stackto thegc_mark_stack ()function is necessary to avoid the inlining of the call togc_mark_stack ().
   (****************************************************************************(****************************************************************************** (Read More) ************(******************************************************************************