Allocate / deallocate metrics

[BratSinot]

Greetings!

I'm trying to figure out the optimal way to have a number of alloc / dealloc metrics.
For now, I have only idea, is make wrapper for system allocator and read atomic counter and "count" them before PrometheusHandle::render.

But this is "unstable" way, because I can't just increase counter in fn alloc() / dealloc() because std allocator have a lot of conditions based on alignment and other stuffs. For now, result code will be like this:

use std::alloc::{GlobalAlloc, Layout};
use std::sync::atomic::{AtomicUsize, Ordering};

pub struct SystemWrapper;

static ALLOC: AtomicUsize = AtomicUsize::new(0);
static DEALLOC: AtomicUsize = AtomicUsize::new(0);

pub fn alloc() -> usize {
    ALLOC.load(Ordering::Relaxed)
}

pub fn dealloc() -> usize {
    DEALLOC.load(Ordering::Relaxed)
}

unsafe impl GlobalAlloc for SystemWrapper {
    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
        let ret = std::alloc::System.alloc(layout);
        if !ret.is_null() {
            ALLOC.fetch_add(1, Ordering::Relaxed);
        }
        ret
    }

    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
        std::alloc::System.dealloc(ptr, layout);
        DEALLOC.fetch_add(1, Ordering::Relaxed);
    }

    unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
        let ret = std::alloc::System.alloc_zeroed(layout);
        if layout.align() <= MIN_ALIGN && layout.align() <= layout.size() && !ret.is_null() {
            ALLOC.fetch_add(1, Ordering::Relaxed);
        }
        ret
    }

    unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
        let ret = std::alloc::System.realloc(ptr, layout, new_size);
        if layout.align() <= MIN_ALIGN && layout.align() <= layout.size() && !ret.is_null() {
            ALLOC.fetch_add(1, Ordering::Relaxed);
        }
        ret
    }
}

// FROM: std::sys::common::alloc::MIN_ALIGN
// The minimum alignment guaranteed by the architecture. This value is used to
// add fast paths for low alignment values.
#[cfg(all(any(
    target_arch = "x86",
    target_arch = "arm",
    target_arch = "mips",
    target_arch = "powerpc",
    target_arch = "powerpc64",
    target_arch = "sparc",
    target_arch = "asmjs",
    target_arch = "wasm32",
    target_arch = "hexagon",
    all(target_arch = "riscv32", not(target_os = "espidf")),
    all(target_arch = "xtensa", not(target_os = "espidf")),
)))]
pub const MIN_ALIGN: usize = 8;
#[cfg(all(any(
    target_arch = "x86_64",
    target_arch = "aarch64",
    target_arch = "mips64",
    target_arch = "s390x",
    target_arch = "sparc64",
    target_arch = "riscv64",
    target_arch = "wasm64",
)))]
pub const MIN_ALIGN: usize = 16;
// The allocator on the esp-idf platform guarantees 4 byte alignment.
#[cfg(all(any(
    all(target_arch = "riscv32", target_os = "espidf"),
    all(target_arch = "xtensa", target_os = "espidf"),
)))]
pub const MIN_ALIGN: usize = 4;

[tobz]

Sorry, I'm not sure what your question is.