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

pub fn reset_peak_usage(&self)

Resets the peak usage to the value currently in memory

Trait Implementations

impl Clone for PeakAlloc

fn clone(&self) -> PeakAlloc

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PeakAlloc

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

Formats the value using the given formatter.

impl Default for PeakAlloc

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.

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.

impl Copy for PeakAlloc