Struct PeakRecordingPool 

pub struct PeakRecordingPool { /* private fields */ }

Wraps a MemoryPool, recording the high-water mark of MemoryPool::reserved as reservations come and go.

Every method delegates to the wrapped pool, so wrapping does not change how memory is granted, limited, or reported. The one thing it does change is downcasting: rt.memory_pool.downcast_ref::<FairSpillPool>() now finds this wrapper instead of the pool it wraps. Nothing in the benchmarks relies on that, and Self::from_pool uses the same mechanism to find the recorder.

Both high-water marks are held per instance, so a benchmark that builds a fresh runtime per query gets a reading scoped to that query without any coordination.

Example

let recording = Arc::new(PeakRecordingPool::new(Arc::new(GreedyMemoryPool::new(1024))));
let pool: Arc<dyn MemoryPool> = Arc::clone(&recording) as _;

let reservation = MemoryConsumer::new("example").register(&pool);
reservation.try_grow(512)?;
reservation.shrink(512);

// The pool is back to empty, but the high-water mark is retained.
assert_eq!(pool.reserved(), 0);
assert_eq!(recording.peak_reserved(), 512);

// The recorder can also be recovered from the pool it was installed as.
assert_eq!(PeakRecordingPool::from_pool(&*pool).unwrap().peak_reserved(), 512);

Implementations

impl PeakRecordingPool

pub fn new(inner: Arc<dyn MemoryPool>) -> Self

Wrap inner, recording its peak reservation from here on.

inner is expected to be empty: the running total starts at zero, so anything reserved before wrapping is not counted.

pub fn from_pool(pool: &dyn MemoryPool) -> Option<&Self>

The recorder installed as pool, if there is one.

Returns None whenever a benchmark runs without a memory limit, since CommonOpt::runtime_env_builder only installs the wrapper alongside a pool it has a limit for.

pub fn peak_reserved(&self) -> usize

Peak reservation, in bytes, since the last Self::reset_peak.

pub fn max_reserved(&self) -> usize

Peak reservation, in bytes, since this pool was created.

Unlike Self::peak_reserved this is never reset, so it reports the peak across every query that shared this pool.

pub fn reset_peak(&self)

Reset the value returned by Self::peak_reserved to what is reserved right now, so the next reading covers only what follows.

BenchmarkRun::start_new_case calls this, giving each benchmark query its own reading. Anything still held when a query starts — data the benchmark loaded up front, say — stays in the reading, since the query runs with those bytes reserved.

Trait Implementations

impl Debug for PeakRecordingPool

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

Formats the value using the given formatter.

impl Display for PeakRecordingPool

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

Formats the value using the given formatter.

impl MemoryPool for PeakRecordingPool

fn name(&self) -> &str

Return pool name

fn register(&self, consumer: &MemoryConsumer)

Registers a new MemoryConsumer

fn unregister(&self, consumer: &MemoryConsumer)

Records the destruction of a MemoryReservation with MemoryConsumer

fn grow(&self, reservation: &MemoryReservation, additional: usize)

Infallibly grow the provided reservation by additional bytes

fn shrink(&self, reservation: &MemoryReservation, shrink: usize)

Infallibly shrink the provided reservation by shrink bytes

fn try_grow( &self, reservation: &MemoryReservation, additional: usize, ) -> Result<()>

Attempt to grow the provided reservation by additional bytes

fn reserved(&self) -> usize

Return the total amount of memory reserved

fn memory_limit(&self) -> MemoryLimit

Return the memory limit of the pool