/ogc

A minimal mark-and-sweep garbage collector

Primary LanguageC

OGC: Ordinary Garbage Collector

About

OGC implements the typical "mark and sweep" algorithm. It works as follows:

  • there is an internal struct representing a block of memory
  • there is a list of blocks representing the allocated memory, and another list representing the local stack of memory
  • once a new object is created,
    • its memory is allocated and its meta data is added to both lists
    • there is a threshold for the number of objects to allocate before cleaning up the memory
    • when the threshold is met:
      • call "mark" with the local stack of memory ("reachable" memory)
      • mark recurses through the list and set a "mark" flag for every block reachable from the inital list of reachable memory
      • we then call "sweep" with the global allocated memory list
      • every block that is not marked is not used, and can be freed and popped from given list

How it works

For a basic mark and sweep garbage collector, two things are required:

  • a list of all of the allocations made by the program;
  • a list of all the allocations in use by the program at any given time;

With these two things the algorithm is simple - compare the two lists and free any allocations which are in the first list, but not in the second - exactly those allocations which are no longer in use.

To get a list of all the allocations made by the progam is relatively simple. We make the programmer use a special function we have prepared (in this case gc_alloc) which allocates memory, and then adds a pointer to that memory to an internal list. If at any point this allocation is freed (such as by gc_free), it is removed from the list.

Function list

  • gc_alloc()

    • Allocates a space in memory of the size which the user requests
    • Ensures the user entered a number > 0
    • Attempts to find a freed block of memory to reuse.
    • On success, returns the address of the newly allocated memory. Otherwise, returns NULL.
  • gc_free()

    • Marks the object as free in the list of objects
    • Ensures the pointer isn't NULL or already free before marking it
  • gc_run()

    • Recursively marks all reachable objects in the list of objects
    • Recursively sweeps (frees) all unmarked (unreachable) objects