Crate arena_alligator 

Arena allocator for building bytes::Bytes without copying the final payload.

Write into a Buffer, call freeze(), and get back Bytes backed by arena memory. The slot or block returns to the arena when the last Bytes reference drops.

Arena selection

FixedArena is the recommended high-throughput path when one slot size covers the workload. Fixed uses uniform slots and a bitmap claim path.

BuddyArena covers variable-size allocation from one shared region. Requests are rounded up to powers of two, larger blocks split on demand, and neighbors coalesce on release.

Both produce the same Buffer type with identical write and freeze semantics.

Quick start

use std::num::NonZeroUsize;
use arena_alligator::FixedArena;
use bytes::BufMut;

let arena = FixedArena::with_slot_capacity(
    NonZeroUsize::new(1024).unwrap(),
    NonZeroUsize::new(4096).unwrap(),
)
    .build()
    .unwrap();

let mut buf = arena.allocate().unwrap();
buf.put_slice(b"hello");
let bytes = buf.freeze();
assert_eq!(&bytes[..], b"hello");

Auto-spill

.auto_spill() changes overflow writes from panic-on-capacity to heap spill. The arena allocation is released as soon as the spill happens.

Initialization policy

The default policy is InitPolicy::Uninit, which matches Rust’s common writable-uninitialized-memory model: newly allocated capacity is not zero-filled, and only the bytes written become visible in the frozen Bytes.

InitPolicy::Zero clears reused arena memory before it is handed back to a writer. That adds work on every allocation in exchange for a stronger zero-on-allocate guarantee.

Frozen slice retention

Freezing a buffer transfers ownership of the arena slot (or buddy block) to the returned Bytes. Cloning or slicing that Bytes shares the reference, so the arena memory stays pinned until every clone and slice is dropped.

BytesExt::into_owned() copies frozen bytes into fresh owned mutable storage.

Async allocation

With the async-alloc feature, AsyncFixedArena and AsyncBuddyArena provide allocate_async() which waits until capacity is available.

Structs

AsyncBuddyArena

Async-capable wrapper around BuddyArena.

AsyncFixedArena

Async-capable wrapper around FixedArena.

BuddyArena

Buddy-backed arena allocator.

BuddyArenaBuilder

Builder for BuddyArena.

BuddyArenaMetrics

Snapshot of buddy arena metrics.

BuddyGeometry

Validated buddy arena geometry.

Buffer

A writable buffer backed by arena memory.

BufferFullError

Buffer capacity exceeded.

FixedArena

Fixed-size slot arena allocator.

FixedArenaBuilder

Builder for FixedArena.

FixedArenaMetrics

Snapshot of fixed arena metrics.

NotifyWaiters

Per-order waiter system.

Unfaulted

An arena whose backing pages have not yet been faulted.

Enums

AllocError

Allocation failed.

BuildError

Builder configuration error.

InitPolicy

Initialization policy applied to each buffer on allocate.

PageSize

Page size used for prefaulting the arena backing allocation.

Traits

BuddyWaiter

Wait strategy for buddy arena async allocation.

BytesExt

Extension methods for converting Bytes into owned mutable storage.

WaitRegistration

Registration returned by waiter traits.

Waiter

Wait strategy for fixed arena async allocation.