alloc_fixed.FixedBuffer

1/// This owner allocates from a byte slice the caller already owns, with no2/// allocator behind it, providing a fixed-capacity buffer allocator over that3/// slice. With observation left off (`-Dobserve-allocations=false`), it is4/// `std.heap.FixedBufferAllocator` itself. With observation compiled in5/// (`-Dobserve-allocations=true`), it is `ObservedFixedBuffer`, a wrapper6/// holding a `std.heap.FixedBufferAllocator` and a producer identity.7///8/// ### Owner stability and address requirements9/// The owner struct stays alive and at one memory address while a borrowed10/// allocator handle is in use. One owner serves one buffer, and the caller11/// takes no copy of it to act as a second allocator over that same storage.12///13/// ### Memory operations and reclamation14/// Memory is cut in order from the start of the buffer up to the byte offset15/// the allocations have reached inside the buffer, the *bump frontier*. Freeing16/// or shrinking the most recent allocation lowers the frontier. Freeing an17/// earlier allocation leaves its space taken until `reset()` rewinds the18/// frontier. Calling `reset()` rewinds the frontier to zero and leaves every19/// active allocation invalid, so the space can be used again.20///21/// ### Concurrency and thread safety22/// The ordinary `allocator()` handle needs the caller to serialize access. The23/// `threadSafeAllocator()` handle advances the frontier with lock-free24/// compare-and-swap inside the standard library allocator. With observation on,25/// the instrumented callbacks and the observation bookkeeping carry no such26/// guarantee and handle their own concurrency. Calling `used()` or reading the27/// owner's fields while thread-safe operations run leaves a data race. A caller28/// keeps concurrent calls to `allocator()` and to `threadSafeAllocator()`29/// apart, and leaves `reset()` alone while thread-safe operations may be30/// running. Calling `Tracked.status()` needs the caller's own serialization.31pub const FixedBuffer = if (observe.enabled)32    ObservedFixedBuffer33else34    std.heap.FixedBufferAllocator;

1/// `FixedBuffer` is a fixed-capacity bump allocator that cuts allocations from2/// a caller-owned byte slice with no allocator behind it. With allocation3/// observation compiled in (`-Dobserve-allocations=true`) it resolves to4/// `ObservedFixedBuffer`, and with observation off it is5/// `std.heap.FixedBufferAllocator`.6pub const FixedBuffer = fixed.FixedBuffer;