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 resource groups.

Resource groups

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

Token guard

When an resource group is registered, an ResourceGroupToken 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’s dropped.

This allows for arbitrarily nested resource groups.

Changes to memory layout

In order to associate an allocation with the current resource group, a small trailer is added to the requested allocation layout, in the form of a pointer to the statistics for the resource 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’s 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.