---

This morning I learned some memory allocation stuff.

I learned a neat trick to implement dynamic arrays. You ask the OS to reserve a large amount of memory upfront. When you grow the array, you commit pages as required. You will never pay the cost of the base pointer changing on you since the upfront reservation gives you a contiguous region in virtual memory space.

This trick excites me greatly.

I learned how to implement a stack + free list combo. You start with a stack allocator. Then if you want to free things in the middle, go right ahead, and add that chunk to the free list (which btw is a linked list). When you push stuff to the stack, you first iterate through the linked list to check for any free chunks.

Cool!

Finally, I learned about two things: the null garbage collector and a memory arena.

The idea of a memory arena is to bundle lifetimes. Absent an arena (or any other allocation strategy), if you need to allocate N things, you will need to explicitly free those N things. When you use a memory arena, you allocate within the context of the arena. The lifetime of each allocation gets tied to the lifetime of the arena. This shifts the concern of release to a per-arena concern instead of a per-allocation concern.

Null garbage collector: It turns out you don't need to worry about memory leaks if you write code that runs on a missile -- the missile ceases to exist at time T and you have enough memory M such that you don't run out of memory before time T.

Feeling inspired by the missile example, we might write the following code:

void Foo(arena)
{
  // allocate some stuff using arena.
}

void Bar()
{
  let arena;
  Foo(arena);
}

Foo can just leak memory -- it doesn't need to care. It relies on the null garbage collector, which is the eventual destruction of the memory arena.