Struct CountingAlloc 

pub struct CountingAlloc<A, T = Untagged> { /* private fields */ }

A global allocator around inner that counts what is asked of it: the bytes live, their peak, and the calls to alloc, alloc_zeroed and realloc. It counts each Layout’s size, never the inner allocator’s own overhead.

Make it a static, with #[global_allocator] to count a whole program, or called directly as a test does. A program with shuyi-app or shuyi-cli already has one (the global module says which).

use shuyi_alloc_count::CountingAlloc;
use std::alloc::System;

static HEAP: CountingAlloc<System> = CountingAlloc::new(System);

assert_eq!(HEAP.live_bytes(), 0);

CountingAlloc::new counts the whole; CountingAlloc::with_tags also counts by memory tag (tags), with a header in front of each block (Tagged).

On a target with atomics each count is one atomic read-modify-write, so any thread may allocate; on one without (an old ARM console) the counts are plain cells, and the target has one thread.

Implementations

impl<A> CountingAlloc<A, Tagged>

pub const fn with_tags(inner: A) -> Self

A counter around inner that also counts by memory tag (tags): each block counts under the tag current on its thread when it was allocated, or last reallocated. It costs a header in front of each block (Tagged).

pub fn rows(&self) -> Vec<TagCounts>

Every tag with bytes live or ever allocated under it, by number, with its class, name and counts. It allocates the list: never call it from inside an allocator.

impl<A> CountingAlloc<A>

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

A counter around inner, nothing counted yet. It counts the whole, with no header in front of a block: for a bench, and a console that counts its heap without tags.

impl<A, T> CountingAlloc<A, T>

pub fn live_bytes(&self) -> usize

The bytes allocated and not yet freed.

pub fn peak_bytes(&self) -> usize

The most bytes live at once since the start or the last reset_peak.

pub fn reset_peak(&self)

Starts the peak again from the bytes live now. A tag’s peak (TagCounts::peak_bytes) stays.

pub fn take_allocs(&self) -> u32

The calls to alloc, alloc_zeroed and realloc since the last take (or the start), read and reset in one step; at most u32::MAX.

pub fn counts(&self) -> Counts

All three: the live bytes, their peak, and the calls, taken (take_allocs).

Trait Implementations

impl<A: Debug, T: Debug> Debug for CountingAlloc<A, T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<A: GlobalAlloc> GlobalAlloc for CountingAlloc<A, Tagged>

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

Allocates memory as described by 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 dealloc(&self, block: *mut u8, layout: Layout)

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

unsafe fn realloc( &self, block: *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.

impl<A: GlobalAlloc> GlobalAlloc for CountingAlloc<A>

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

Allocates memory as described by 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 dealloc(&self, ptr: *mut u8, layout: Layout)

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

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.