Struct Patience 

pub struct Patience {
    pub min_measured: usize,
    pub max_misses: usize,
}

When to stop measuring an ordered group: once at least min_measured of its members were measured and the last max_misses of them in a row missed, none faster than the group’s leader by more than 2%. The leader is the first member measured, then each member that was faster than it by more than 2%.

The group is benchmarked best first, so a run of members that cannot beat its leader says the rest of the order is unlikely to either, and they are never compiled. The members already measured still compete as usual, the ones skipped are reported as such, and the rest of the batch is measured as if the group had ended there. A member is skipped only when every group that brought it into the batch ran out of patience. Should every member measured fail later on, the skipped ones are measured after all.

A member is judged on its best first-pass time, which follows a single warmup: a lucky one makes a leader the rest of the group struggles to beat. A member that fails is neither measured nor a miss: it says nothing about how the order is faring.

Adaptive scheduler only: the fixed-count pass, the only one on wasm, measures every member.

Fields

min_measured: usize

Members measured before the group may stop. One member is always measured.

max_misses: usize

Members in a row that miss before the group stops. Zero stops it at min_measured, whatever they measured.

Trait Implementations

impl Clone for Patience

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Patience

impl Debug for Patience

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

Formats the value using the given formatter.

impl Eq for Patience

impl PartialEq for Patience

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Patience