Memory per phase with a counting allocator d443639bcf35

//! A counting allocator for measuring memory (`--features alloc-stats` on

//! the `oxy` binary, with `OXY_TIMINGS=1`): each timing phase then also

//! reports live bytes, the peak so far and what the phase allocated, so a

//! profile names the structure that holds the memory.

use std::alloc::{GlobalAlloc, Layout, System};

use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering::Relaxed};

static LIVE: AtomicUsize = AtomicUsize::new(0);

static PEAK: AtomicUsize = AtomicUsize::new(0);

static TOTAL: AtomicUsize = AtomicUsize::new(0);

static COUNT: AtomicUsize = AtomicUsize::new(0);

static ACTIVE: AtomicBool = AtomicBool::new(false);

/// The system allocator, counting. Install it with

/// `#[global_allocator] static A: Counting = Counting;`.

pub struct Counting;

impl Counting {

    fn grew(n: usize) {

        ACTIVE.store(true, Relaxed);

        let live = LIVE.fetch_add(n, Relaxed) + n;

        TOTAL.fetch_add(n, Relaxed);

        COUNT.fetch_add(1, Relaxed);

        PEAK.fetch_max(live, Relaxed);

    }

}

unsafe impl GlobalAlloc for Counting {

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

        let p = System.alloc(l);

        if !p.is_null() {

            Self::grew(l.size());

        }

        p

    }

    unsafe fn alloc_zeroed(&self, l: Layout) -> *mut u8 {

        let p = System.alloc_zeroed(l);

        if !p.is_null() {

            Self::grew(l.size());

        }

        p

    }

    unsafe fn dealloc(&self, p: *mut u8, l: Layout) {

        System.dealloc(p, l);

        LIVE.fetch_sub(l.size(), Relaxed);

    }

    unsafe fn realloc(&self, p: *mut u8, l: Layout, new: usize) -> *mut u8 {

        let q = System.realloc(p, l, new);

        if !q.is_null() {

            LIVE.fetch_sub(l.size(), Relaxed);

            Self::grew(new);

        }

        q

    }

}

/// What the counting allocator has seen, when it is installed.

#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]

pub struct Stats {

    /// Bytes allocated and not yet freed.

    pub live: usize,

    /// The most `live` has been.

    pub peak: usize,

    /// Bytes ever allocated.

    pub total: usize,

    /// Allocations ever made.

    pub count: usize,

}

/// The counters, or `None` when the counting allocator is not installed.

pub fn stats() -> Option<Stats> {

    ACTIVE.load(Relaxed).then(|| Stats {

        live: LIVE.load(Relaxed),

        peak: PEAK.load(Relaxed),

        total: TOTAL.load(Relaxed),

        count: COUNT.load(Relaxed),

    })

}

[features]

# A counting global allocator: OXY_TIMINGS=1 then reports memory per phase.

alloc-stats = []

pub mod alloc_stats;

//! without a profiler. With the counting allocator installed (the `oxy`

//! binary's `alloc-stats` feature), each also prints live and peak memory

//! and what the phase allocated.

    /// Allocator counters at the start, when counting.

    mem: Option<crate::alloc_stats::Stats>,

    let on = enabled();

        started: on.then(Instant::now),

        mem: if on {

            crate::alloc_stats::stats()

        } else {

            None

        },

    }

}

fn mib(n: usize) -> f64 {

    n as f64 / (1024.0 * 1024.0)

}

/// The allocator's counters as one line, when counting: for the end of a

/// command.

pub fn memory_summary() {

    if let (true, Some(s)) = (enabled(), crate::alloc_stats::stats()) {

        eprintln!(

            "memory peak {:.1} MiB, live {:.1} MiB, {:.1} MiB in {} allocations",

            mib(s.peak),

            mib(s.live),

            mib(s.total),

            s.count

        );

            let ms = t.elapsed().as_secs_f64() * 1000.0;

            match (self.mem, crate::alloc_stats::stats()) {

                (Some(a), Some(b)) => eprintln!(

                    "timing {:<28} {:>9.2} ms  live {:>8.1} MiB  peak {:>8.1} MiB  +{:.1} MiB in {} allocs",

                    self.name,

                    ms,

                    mib(b.live),

                    mib(b.peak),

                    mib(b.total - a.total),

                    b.count - a.count

                ),

                _ => eprintln!("timing {:<28} {:>9.2} ms", self.name, ms),

            }

The repository file wins. `OXY_HOME` relocates the user directory. `OXY_TIMINGS=1` prints how long each phase of a snapshot takes (loading the base state, rendering it, reading the working copy, building the change) to standard error, for finding out where a slow command spends its time. Built with `cargo build --release --features alloc-stats`, oxy also reports each phase's live and peak memory and what it allocated, and a summary at the end.

#[cfg(feature = "alloc-stats")]

#[global_allocator]

static ALLOC: oxy_core::alloc_stats::Counting = oxy_core::alloc_stats::Counting;

    let result = cli::run();

    oxy_core::timing::memory_summary();

    match result {