한꺼번에 해제하는 아레나 할당자

An ArenaAllocator groups many allocations together so you can release them all in a single step, instead of freeing each one by hand. 🧹

An arena does not get memory from thin air. You hand it a backing allocator, and the arena requests memory from it in larger chunks.

Like other allocators, call allocator() to get the interface. Every allocation made through it is tracked inside this single arena.

Calling deinit() on the arena frees every allocation at once. You never call free on the individual pieces you carved out.

Inside an arena, calling free on a single item is essentially a no-op. The memory is only truly reclaimed when the whole arena is torn down.

Arenas shine for work with a clear lifetime: parse a request, build a tree, render a frame, then drop everything in one clean sweep.

Because you free in bulk, you avoid tracking many tiny lifetimes. This simplicity removes a whole class of leak and double-free bugs.

Allocating from an arena is usually fast: it often just bumps a pointer forward in the current chunk instead of searching free lists.

The trade-off is that nothing is freed early. If allocations live long or grow without bound, an arena can hold more memory than you expect.

You can also call reset() to reclaim memory while keeping the arena alive, which is handy when you reuse it across many cycles.

The shape is familiar: init with a backing allocator, defer deinit, then allocate freely and let the single teardown clean up everything.

Recall how memory is released when you use an arena.

You learned the ArenaAllocator: built on a backing allocator, fast to allocate, and freed in one bulk step that is ideal for short-lived work. 🎯