Struct Tolerance 

pub struct Tolerance {
    pub tasks: usize,
    pub descriptors: usize,
    pub outstanding: usize,
    pub resident_kb: usize,
}

How much drift is noise rather than a leak.

Not zero, and the reason is worth stating: a runtime keeps blocking-pool threads alive after use, an allocator does not return every page, and a descriptor may still be in TIME_WAIT. A tolerance of zero produces a test that fails at random, and a test that fails at random is a test that gets deleted.

Fields

tasks: usize

Extra tasks allowed at the end.

descriptors: usize

Extra descriptors allowed.

outstanding: usize

Extra outstanding items allowed.

resident_kb: usize

Extra resident kilobytes allowed.

Much the largest tolerance here, and it has to be. An allocator does not return every freed page to the kernel, a runtime grows its per-thread caches on first use, and the first few hundred calls touch code paths that are still being faulted in. Sixteen megabytes is loose enough not to fail on any of that and tight enough that a leak of a kilobyte per call shows up within a few thousand calls.

Trait Implementations

impl Clone for Tolerance

fn clone(&self) -> Tolerance

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Tolerance

impl Debug for Tolerance

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

Formats the value using the given formatter.

impl Default for Tolerance

fn default() -> Self

Returns the “default value” for a type.