Struct LatencySampler 

pub struct LatencySampler {
    inner: EventCounter,
    display_name: String,
}

A Counter that records one latency sample per event (e.g. one per GC pause, for things like time-to-yield or pause time) and reports it as p50/p9999 columns instead of a raw per-phase total.

This is a thin wrapper around an EventCounter: it reuses the inner counter’s start/stop/phase_change machinery unchanged to accumulate one sample per pause into the per-phase array. It only overrides how the counter is named and printed, bending two parts of the Counter contract to do so:

• Counter::merge_phases always returns true.
• Counter::name returns a compound, tab-separated pair of column names (e.g. "pause-time.p50\tpause-time.p9999"), so the single print!("{}\t", c.name()) call site in crate::util::statistics::stats::Stats::print_column_names prints both headers.
• Counter::print_total prints "{p50}\t{p9999}" (two tab-separated values, ignoring the other argument), so the single c.print_total(None) call site in crate::util::statistics::stats::Stats::print_stats prints both values.

This trick only works because Counter::name() has a single caller (Stats’s own printing code) anywhere in the codebase; if that changes, this would need revisiting.

Fields

inner: EventCounter

display_name: String

A compound "{name}.p50\t{name}.p9999" string, returned by name().

Implementations

impl LatencySampler

pub fn new(name: &str, stats: Arc<SharedStats>, implicitly_start: bool) -> Self

pub fn record(&mut self, value: u64)

Record one latency sample (e.g. a duration in nanoseconds).

fn samples(&self) -> Vec<u64>

The recorded samples, one per pause. Every sample is recorded during the STW phase (see record), so only the odd-indexed phase counts hold real values; the even-indexed (mutator-phase) ones are always 0 and are skipped here.

Trait Implementations

impl Counter for LatencySampler

fn start(&mut self)

Start the counter

fn stop(&mut self)

Stop the counter

fn phase_change(&mut self, old_phase: usize)

Signal a change in GC phase.

fn print_count(&self, phase: usize)

Print the counter value for a particular phase

fn get_total(&self, other: Option<bool>) -> u64

Get the total count over past phases

fn print_total(&self, _other: Option<bool>)

Print the total count over past phases

fn print_min(&self, other: bool)

Print the minimum count of the past phases

fn print_max(&self, other: bool)

Print the maximum count of the past phases

fn print_last(&self)

Print the count of the last phases

fn merge_phases(&self) -> bool

Whether the counter merges other and stw phases.

fn implicitly_start(&self) -> bool

Whether the counter starts implicitly after creation

fn name(&self) -> &String

Get the name of the counter