Crate redox_buffer_pool

redox-buffer-pool

This crate provides a buffer pool for general-purpose memory management, with support for allocating slices within the pool, as well as expanding the pool with potentially non-adjacent larger underlying memory allocations, like mmap(2) or other larger possible page-sized allocations.

The current allocator uses one B-trees to partition the space into regions either marked as occupied or free. The keys used by the B-tree have a custom comparator, which ensures that keys for used ranges are orderered after the keys for free ranges. This, together with having a free space tree, makes acquiring buffer slices possible in O(log n), provided that there is already an aligned range (otherwise, it simply does linear search in O(n) until it finds a range large enough to account for the misalignment).

Structs

BeginExpandError	The error internally caused by arithmetic overflow, that indicates the buffer pool has no more usable ranges.
BufferPool	A buffer pool, featuring a general-purpose 32-bit allocator, and slice guards.
BufferPoolOptions	Various options used by the buffer pool mainly to limit the range of possible sizes and alignments.
BufferSlice	A slice from the buffer pool, that can be read from or written to as a regular smart pointer.
CloseError	The error from BufferPool::close, meaning that there is currently a guarded buffer slice in use by the pool, preventing resource freeing.
ExpandHandle	A handle for expansion. When this handle is retrieved by the BufferPool::begin_expand method, the range has already been reserved, so it's up to this handle to initialize it.
ReclaimError	The potential error from BufferSlice::reclaim, caused by the slice being guarded.
WithGuardError	The potential error from BufferSlice::with_guard or BufferSlice::guard, indicating that a different guard is already in use by the the buffer slice. Since that method takes self by value, the old self is included here, to allow for reuse in case of failure.

Enums

AllocationStrategy	The strategy to use when allocating, with tradeoffs between heap fragmentation, and the algorithmic complexity of allocating.
NoGuard	A no-op guard, that cannot be initialized but still useful in type contexts..
NoHandle	A handle type that cannot be initialized, causing the handle to take up no space in the buffer pool struct.

Traits

Guard	The requirement of a guard to a slice. Guards can optionally prevent slices from being reclaimed; the slices have a fallible BufferSlice::reclaim method, but their Drop impl will cause the memory to leak if it's still protected by the guard. This is especially useful when the buffers are shared with another process (io_uring for instance), or by hardware, since this prevents data races that could occur, if a new buffer for a different purpose happens to use the same memory as an old buffer that hardware e.g. thinks it can write to.
Handle	The requirement of a handle to be able to be passed into the buffer pool.
Integer	A type that can be used as offsets and lengths within a buffer pool. The default integer is u32.