A set data-structure used to batch remote free operations.

A variant of `TypedArray` that unmaps its memory during `drop`.

A `Vec`-like structure parametric on an `Alloc`. The overall structure here borrows heavily from the smallvec crate, though our goals here are of cour

A builder-pattern-style builder for `MagazineAllocator`s and `LocalAllocator`s. ```rust,ignore // A usize-specific allocator using the `LocalCache` f

An iterator over a claimed `Slag`'s bitset.

A trait encapsulating the notion of an array of size classes for an allocator.

Counters for various useful events. Primarily used for debugging and performance.

Types that can be unwrapped in an allocation-safe manner. [`AllocUnwrap`] provides the [`alloc_unwrap`] and [`alloc_expect`] methods, which are alloc

A pair of `UntypedObjectAlloc`s to provide memory for a slab allocator. A `BackingAlloc` encapsulates a pair of allocator types that are used to prov

A concurrent bag data-structure built from sharding requests over other bags. `BagPipe` implements both `SharedWeakBag` and `WeakBag`. Using this as

An allocator that allocates objects at the granularity of the page size of the underlying `MemorySource`.

Configuration to customize a stack-based slab implementation. `ConfigData` completes the stack-based slab implementation by providing post-alloc and

A type to test for memory corruption issues. The `CorruptionTester` is designed to be able to detect when an allocated value has been corrupted, whic

An object for use in corruption tests that implements `Default`. `CorruptionTesterDefault` objects are objects that are allocated by an `ObjectAlloc`

An object for use in corruption tests constructed by `unsafe_default`. `CorruptionTesterUnsafe` objects are objects that are allocated by an `ObjectA

A trait that abstracts over `CorruptionTesterDefault` and `CorruptionTesterUnsafe`.

A `DirtyFn` is a callback that is called upon allocating a clean page from a `PageAlloc`. It generally does nothing, but its presence in `PageAlloc` a

A global handle that can hand out thread-local handles to the allocator.

A Dynamic memory allocator, parmetrized on a particular `ObjectAlloc`, `CourseAllocator` and `AllocMap`. `ElfMalloc` encapsulates the logic of constr

A zero-sized type used for implementing `Alloc` and `LayoutFinder` for the global instance of elfmalloc.

A newtype wrapper around `ElfMalloc<Source>` that sends its contents to the background thread in its destructor.

Another fetch-add based concurrent queue. This queue is based on the `FAAArrayQueue` of Pedro Ramalhete over at [Concurrency Freaks][1]. The impleme

The type of the global instance of the allocator. This is used to create handles for TLS-stored `GlobalAllocator`s.

A wrapper like `DynamicAllocator` in the parent module. The reason we have a wrapper is for this module's custom `Drop` implementation, mentioned in

The type for messages sent to the background thread. These can either be arrays of size classes to be cleaned up (in the case of thread destruction) o

A system to perform initialization of objects. Since slab allocators can either initialize their objects or not, we need a way of abstracting over th

To make testing easier with APIs that deal with both `NonNull<u8>` and `*mut u8`.

A mechanism for mapping allocated objects to their `Layout`s. A `LayoutFinder` is an object that can store and look up the `Layout` associated with a

A `Lazy` instance of a type `T` keeps `T::Params` strict but only initializes the value with `T::init` when it is first accessed. `Lazy` implements `

A `LazyInitializable` type can be constructed from `Params`. Types that implement this trate can be wrapped in the `Lazy` construct.

A `LocalCache` provides thread-local data on top of a `SlagAllocator`. Like a `MagazineCache`, it includes a stack of pointers to cache allocations.

A fixed-size stack backed by `mmap`. A `Magazine` is a lot like a `PtrStack`. The primary difference is that a `Magazine` stores its data inline, whe

A different approach to caching to `LocalCache` inspired by Bonwick-style magazines. The advantage `MagazineCache` has over `LocalCache` is that it w

An implementation of the C allocation API. The `Malloc` trait extends a type which implements `Alloc` for a reference to itself¹ by provid

A `MemorySource` that can tell which pointers lie in a region returned by `carve`.

A generator of chunks of memory providing an `sbrk`-like interface.

An array of size classes where sizes are multiples of 16.