alloc_stats.rs 17.4%

8 of 46 lines run, 2 of 16 functions · run #401 on subrepo-pin-state · run missed

//! 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),
    })
}

/// Give pages the program has freed back to the system. glibc keeps freed
/// memory in each thread's arena; after a large merge renders thousands of
/// files on many threads, that kept memory is most of the process's size
/// (#25). Elsewhere it does nothing.
pub fn release_freed_memory() {
    #[cfg(all(target_os = "linux", target_env = "gnu"))]
    // SAFETY: malloc_trim only returns free pages to the system; it is
    // safe to call at any time from any thread.
    unsafe {
        libc::malloc_trim(0);
    }
}

1		//! A counting allocator for measuring memory (`--features alloc-stats` on
2		//! the `oxy` binary, with `OXY_TIMINGS=1`): each timing phase then also
3		//! reports live bytes, the peak so far and what the phase allocated, so a
4		//! profile names the structure that holds the memory.
5
6		use std::alloc::{GlobalAlloc, Layout, System};
7		use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering::Relaxed};
8
9		static LIVE: AtomicUsize = AtomicUsize::new(0);
10		static PEAK: AtomicUsize = AtomicUsize::new(0);
11		static TOTAL: AtomicUsize = AtomicUsize::new(0);
12		static COUNT: AtomicUsize = AtomicUsize::new(0);
13		static ACTIVE: AtomicBool = AtomicBool::new(false);
14
15		/// The system allocator, counting. Install it with
16		/// `#[global_allocator] static A: Counting = Counting;`.
17		pub struct Counting;
18
19		impl Counting {
20	0×	fn grew(n: usize) {
21	0×	ACTIVE.store(true, Relaxed);
22	0×	let live = LIVE.fetch_add(n, Relaxed) + n;
23	0×	TOTAL.fetch_add(n, Relaxed);
24	0×	COUNT.fetch_add(1, Relaxed);
25	0×	PEAK.fetch_max(live, Relaxed);
26	0×	}
27		}
28
29		unsafe impl GlobalAlloc for Counting {
30	0×	unsafe fn alloc(&self, l: Layout) -> *mut u8 {
31	0×	let p = System.alloc(l);
32	0×	if !p.is_null() {
33	0×	Self::grew(l.size());
34	0×	}
35	0×	p
36	0×	}
37	0×	unsafe fn alloc_zeroed(&self, l: Layout) -> *mut u8 {
38	0×	let p = System.alloc_zeroed(l);
39	0×	if !p.is_null() {
40	0×	Self::grew(l.size());
41	0×	}
42	0×	p
43	0×	}
44	0×	unsafe fn dealloc(&self, p: *mut u8, l: Layout) {
45	0×	System.dealloc(p, l);
46	0×	LIVE.fetch_sub(l.size(), Relaxed);
47	0×	}
48	0×	unsafe fn realloc(&self, p: mut u8, l: Layout, new: usize) -> mut u8 {
49	0×	let q = System.realloc(p, l, new);
50	0×	if !q.is_null() {
51	0×	LIVE.fetch_sub(l.size(), Relaxed);
52	0×	Self::grew(new);
53	0×	}
54	0×	q
55	0×	}
56		}
57
58		/// What the counting allocator has seen, when it is installed.
59		#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
60		pub struct Stats {
61		/// Bytes allocated and not yet freed.
62		pub live: usize,
63		/// The most `live` has been.
64		pub peak: usize,
65		/// Bytes ever allocated.
66		pub total: usize,
67		/// Allocations ever made.
68		pub count: usize,
69		}
70
71		/// The counters, or `None` when the counting allocator is not installed.
72	314×	pub fn stats() -> Option<Stats> {
73	314×	ACTIVE.load(Relaxed).then(\|\| Stats {
74	0×	live: LIVE.load(Relaxed),
75	0×	peak: PEAK.load(Relaxed),
76	0×	total: TOTAL.load(Relaxed),
77	0×	count: COUNT.load(Relaxed),
78	0×	})
79	314×	}
80
81		/// Give pages the program has freed back to the system. glibc keeps freed
82		/// memory in each thread's arena; after a large merge renders thousands of
83		/// files on many threads, that kept memory is most of the process's size
84		/// (#25). Elsewhere it does nothing.
85	24×	pub fn release_freed_memory() {
86		#[cfg(all(target_os = "linux", target_env = "gnu"))]
87		// SAFETY: malloc_trim only returns free pages to the system; it is
88		// safe to call at any time from any thread.
89	24×	unsafe {
90	24×	libc::malloc_trim(0);
91	24×	}
92	24×	}

`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet

Coverage / crates/oxy-core/src/alloc_stats.rs 17.4%

Keyboard