Struct Profiler 

pub struct Profiler { /* private fields */ }

Scoped profiler that captures a delta between start and stop.

Read the snapshot of the installed ModAlloc on construction and again on Profiler::stop, returning the difference. If no ModAlloc is installed as #[global_allocator] and no allocation has occurred through it yet, both snapshots are zero and the delta is zero.

Example

use mod_alloc::{ModAlloc, Profiler};

#[global_allocator]
static GLOBAL: ModAlloc = ModAlloc::new();

fn main() {
    let p = Profiler::start();
    let v: Vec<u8> = vec![0; 1024];
    drop(v);
    let stats = p.stop();
    println!("Captured {} alloc events", stats.alloc_count);
}

Implementations

impl Profiler

pub fn start() -> Self

Begin profiling, capturing the current allocation state.

If no ModAlloc is installed as #[global_allocator] or no allocation has occurred yet, the captured baseline is all zeros.

Example

use mod_alloc::Profiler;

let p = Profiler::start();
let _delta = p.stop();

Examples found in repository

examples/basic.rs (line 11)

fn main() {
    let p = Profiler::start();

    let v: Vec<u64> = (0..1_000).collect();
    let sum: u64 = v.iter().sum();
    drop(v);

    let mut owned: Vec<String> = Vec::with_capacity(100);
    for i in 0..100 {
        owned.push(format!("item-{i}"));
    }
    drop(owned);

    let delta = p.stop();
    println!("Profiler delta (alloc/total/current = delta; peak = absolute):");
    println!("  alloc_count:   {}", delta.alloc_count);
    println!("  total_bytes:   {}", delta.total_bytes);
    println!("  current_bytes: {}", delta.current_bytes);
    println!("  peak_bytes:    {}", delta.peak_bytes);

    let snap = GLOBAL.snapshot();
    println!();
    println!("Process-wide snapshot:");
    println!("  alloc_count:   {}", snap.alloc_count);
    println!("  total_bytes:   {}", snap.total_bytes);
    println!("  current_bytes: {}", snap.current_bytes);
    println!("  peak_bytes:    {}", snap.peak_bytes);

    println!();
    println!("(workload checksum: {sum})");
}

pub fn stop(self) -> AllocStats

Stop profiling and return the delta from start.

alloc_count, total_bytes, and current_bytes are deltas from start() to stop(). peak_bytes is the absolute high-water mark observed during the profiling window (peak has no meaningful delta semantic).

Example

use mod_alloc::Profiler;

let p = Profiler::start();
let stats = p.stop();
assert_eq!(stats.alloc_count, 0);

Examples found in repository

examples/basic.rs (line 23)

fn main() {
    let p = Profiler::start();

    let v: Vec<u64> = (0..1_000).collect();
    let sum: u64 = v.iter().sum();
    drop(v);

    let mut owned: Vec<String> = Vec::with_capacity(100);
    for i in 0..100 {
        owned.push(format!("item-{i}"));
    }
    drop(owned);

    let delta = p.stop();
    println!("Profiler delta (alloc/total/current = delta; peak = absolute):");
    println!("  alloc_count:   {}", delta.alloc_count);
    println!("  total_bytes:   {}", delta.total_bytes);
    println!("  current_bytes: {}", delta.current_bytes);
    println!("  peak_bytes:    {}", delta.peak_bytes);

    let snap = GLOBAL.snapshot();
    println!();
    println!("Process-wide snapshot:");
    println!("  alloc_count:   {}", snap.alloc_count);
    println!("  total_bytes:   {}", snap.total_bytes);
    println!("  current_bytes: {}", snap.current_bytes);
    println!("  peak_bytes:    {}", snap.peak_bytes);

    println!();
    println!("(workload checksum: {sum})");
}