Newcomer: Getting into Allocators

bongolin · April 14, 2025, 9:49pm

Hi folks, I’m used to languages with garbage collectors, so I haven’t had much experience working directly with memory allocation like Zig requires with allocators. I’d like to understand more about how allocators work, such as why there are so many different kinds, and how/when to choose one or another.

Can anyone recommend some good resources or content that could help me build a clearer understanding of allocators?

Thank you folks!

Sze · April 14, 2025, 10:08pm

Start with reading this:
https://ziglang.org/documentation/0.14.0/#Choosing-an-Allocator

Here are some more resources:

Learning Zig - Heap Memory & Allocators
3 Memory and Allocators – Introduction to Zig from GitHub - pedropark99/zig-book: An open, technical and introductory book for the Zig programming language 📚📖

vulpesx · April 15, 2025, 2:54am

The zig doc section that @Sze linked needs updating.

While GeneralPurposeAllocator still exists, it’s now an alias to DebugAllocator and has had some internal changes as it’s now only meant for debug builds, for release builds there is smp_allocator which is thread safe and about as fast as glibc malloc, which is very impressive. Everything before GeneralPurposeAllocator is still valid

AndrewKraevskii · April 15, 2025, 6:59pm

If you prefer video content. This is old but good intro to what allocator even is https://youtu.be/vHWiDx_l4V0

Justus2308 · April 15, 2025, 7:57pm

I’ve found this blog post very helpful to get a grasp of how many allocator implementations out there work at a basic level. It introduces a lot of terms and concepts that you will encounter quite frequently when dealing with allocators. It’s not specific to Zig though.

matklad · April 15, 2025, 8:29pm

I also strongly recommend studying the source code of SmpAllocator:

github.com/ziglang/zig

lib/std/heap/SmpAllocator.zig

6c598e834

//! An allocator that is designed for ReleaseFast optimization mode, with
//! multi-threading enabled.
//!
//! This allocator is a singleton; it uses global state and only one should be
//! instantiated for the entire process.
//!
//! ## Basic Design
//!
//! Each thread gets a separate freelist, however, the data must be recoverable
//! when the thread exits. We do not directly learn when a thread exits, so
//! occasionally, one thread must attempt to reclaim another thread's
//! resources.
//!
//! Above a certain size, those allocations are memory mapped directly, with no
//! storage of allocation metadata. This works because the implementation
//! refuses resizes that would move an allocation from small category to large
//! category or vice versa.
//!
//! Each allocator operation checks the thread identifier from a threadlocal
//! variable to find out which metadata in the global state to access, and

This file has been truncated. show original

This is very short (if not very simple) allocator suitable for many workloads, and one of Zig programming gems.

(though, be aware that this allocator doesn’t handle some pathological workloads correctly)

mnemnion · April 15, 2025, 10:44pm

The word ‘correctly’ here makes me nervous.

Does it mean “becomes very slow / wastes a lot of memory”, or does it mean “leaves the heap in an invalid state”?

matklad · April 15, 2025, 11:15pm

See add mpsc example by matklad · Pull Request #1 · andrewrk/CarmensPlayground · GitHub, it can allocate unbounded amount of memory over time for a program with O(1) working set.