Struct TrackingAllocator 

pub struct TrackingAllocator<A> { /* private fields */ }

A global allocator that tracks allocations on a per-group basis.

This allocator provides the ability to track the allocations/deallocations, both in bytes and objects, for different, user-defined allocation groups.

Allocation groups

Allocation (and deallocations) are tracked by allocation group. When this allocator is used, every allocation is associated with an allocation group. Allocation groups are user-defined, except for the default “root” allocation group which acts as a catch-all for allocations when a user-defined group is not entered.

Token guard

When an allocation group is registered, an AllocationGroupToken is returned. This token can be used to “enter” the group, which attribute all allocations on the current thread to that group. Entering the group returns a drop guard that restores the previously entered allocation when it is dropped.

This allows for arbitrarily nested allocation groups.

Changes to memory layout

In order to associate an allocation with the current allocation group, a small trailer is added to the requested allocation layout, in the form of a pointer to the statistics for the allocation group. This allows updating the statistics directly when an allocation is deallocated, without having to externally keep track of what group a given allocation belongs to. These statistics are updated directly when the allocation is initially made, and when it is deallocated.

This means that all requested allocations end up being one machine word larger: 4 bytes on 32-bit systems, and 8 bytes on 64-bit systems.

Implementations

impl<A> TrackingAllocator<A>

pub const fn new(allocator: A) -> Self

Creates a new TrackingAllocator that wraps another allocator.

The wrapped allocator is used to actually allocate and deallocate memory, while this allocator is responsible purely for tracking the allocations and deallocations themselves.

Trait Implementations

impl<A> GlobalAlloc for TrackingAllocator<A>

where A: GlobalAlloc,

unsafe fn alloc(&self, layout: Layout) -> *mut u8

Allocates memory as described by the given layout.

unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout)

Deallocates the block of memory at the given ptr pointer with the given layout.

unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8

Behaves like alloc, but also ensures that the contents are set to zero before being returned.

unsafe fn realloc( &self, ptr: *mut u8, layout: Layout, new_size: usize, ) -> *mut u8

Shrinks or grows a block of memory to the given new_size in bytes. The block is described by the given ptr pointer and layout.