2.2.2 Bump Allocator

struct ZixBumpAllocator

A simple bump-pointer allocator that never frees.

This is about the simplest possible allocator that is useful in practice. It uses a user-provided memory buffer with a fixed size, and allocates by simply “bumping” the top offset like a stack. This approach is simple, extremely fast, and hard real-time safe, but at the cost of being limited to narrow use cases since there is (almost) no support for deallocation.

Using this allocator requires knowing up-front the total amount of memory that will be allocated (without reuse). Typically this makes sense in short scopes like a function call.

This allocator adheres to standard C semantics as much as possible, but is much more restrictive. Specifically:

  • All allocations are aligned to sizeof(uintmax_t).

  • Both free() and realloc() only work on the most recently allocated pointer, essentially serving as a cheap pop and pop-push, respectively.

  • Calling free() means that realloc() will fail and free() will do nothing until the next allocation. In other words, free() can’t be used twice in a row.

  • There is no relocation: realloc() always returns either the input pointer, or null.

ZixAllocator base

Base allocator instance.

void *buffer

User-owned memory buffer.

size_t last

Last allocation offset in bytes.

size_t top

Stack top/end offset in bytes.

size_t capacity

Size of buffer in bytes (the maximum top)

ZixBumpAllocator zix_bump_allocator(size_t capacity, void *buffer)

Return a bump allocator that works within a provided buffer.