Struct peak_alloc::PeakAlloc

pub struct PeakAlloc;

This structure implements a dead simple low-overhead wrapper around the system allocator. It lets a program know its own memory and peak memory consumption at runtime.

Note

The peak allocator is really just a shim around the system allocator. The bulk of its work is delegated to the system allocator and all PeakAlloc does is to maintain the atomic counters.

Example

To make use of the PeakAllocator, all you need to do, is to declare a static instance of it, and annotate it with the #[global_allocator] attribute. Then, in your main module (or anywhere else in your code where it is deemed useful), you just call methods on the static variable you declared.

use peak_alloc::PeakAlloc;

#[global_allocator]
static PEAK_ALLOC: PeakAlloc = PeakAlloc;

fn main() {
    // Do your funky stuff...

    let current_mem = PEAK_ALLOC.current_usage_as_mb();
    println!("This program currently uses {} MB of RAM.", current_mem);
    let peak_mem = PEAK_ALLOC.peak_usage_as_gb();
    println!("The max amount that was used {}", peak_mem);
}

Implementations

impl PeakAlloc

pub fn current_usage(&self) -> usize

Returns the number of bytes that are currently allocated to the process

pub fn peak_usage(&self) -> usize

Returns the maximum number of bytes that have been allocated to the process over the course of its life.

pub fn current_usage_as_kb(&self) -> f32

Returns the amount of memory (in kb) that is currently allocated to the process.

pub fn current_usage_as_mb(&self) -> f32

Returns the amount of memory (in mb) that is currently allocated to the process.

pub fn current_usage_as_gb(&self) -> f32

Returns the amount of memory (in gb) that is currently allocated to the process.

pub fn peak_usage_as_kb(&self) -> f32

Returns the maximum quantity of memory (in kb) that have been allocated to the process over the course of its life.

pub fn peak_usage_as_mb(&self) -> f32

Returns the maximum quantity of memory (in mb) that have been allocated to the process over the course of its life.

pub fn peak_usage_as_gb(&self) -> f32

Returns the maximum quantity of memory (in gb) that have been allocated to the process over the course of its life.

Trait Implementations

impl Clone for PeakAlloc

pub fn clone(&self) -> PeakAlloc

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for PeakAlloc

impl Debug for PeakAlloc

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

Formats the value using the given formatter.

impl Default for PeakAlloc

pub fn default() -> PeakAlloc

Returns the "default value" for a type.

impl GlobalAlloc for PeakAlloc

PeakAlloc only implements the minimum required set of methods to make it useable as a global allocator (with #[global_allocator] attribute).

No funky stuff is done below.

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

Allocate memory as described by the given layout.

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

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

pub 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.

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

Shrink or grow a block of memory to the given new_size. The block is described by the given ptr pointer and layout.