Struct Profile 

pub struct Profile {
    pub name: &'static str,
    pub warmup: usize,
    pub samples: usize,
    pub cold_spawns: usize,
    pub deferred: bool,
}

How much to measure.

Fields

name: &'static str

The name (quick, full, ci).

warmup: usize

Calls before the samples.

samples: usize

Samples per target and cache mode.

cold_spawns: usize

Processes spawned for the process-cold target, and samples per cache mode of a deferred panel: the targets whose one sample costs what a whole quick run does.

deferred: bool

Are the UI’s deferred panels measured? Their sources (the integration queue, the delivery report) are the reason the UI defers them, and one sample of one of them takes longer than every other target together; only full admits them.

Implementations

impl Profile

pub const QUICK: Profile

Fast developer feedback.

pub const FULL: Profile

Stable evidence.

pub const CI: Profile

Structural gates plus a conservative measurement.

pub fn parse(name: &str) -> Option<Profile>

By name.

pub fn admits(&self, target: &BenchmarkTarget) -> bool

Does this profile measure the target? Every target but a deferred panel, which only a profile that admits deferred panels does.

use majordomus_cli::bench::{BenchmarkTarget, Profile, TargetKind, View};
let panel = BenchmarkTarget {
    key: "system.http.ui.panels.drain".into(),
    kind: TargetKind::Page {
        route: "/ui/panels/drain".into(),
        view: View::Pinned,
        deferred: true,
    },
};
assert!(!Profile::QUICK.admits(&panel) && !Profile::CI.admits(&panel));
assert!(Profile::FULL.admits(&panel));

Trait Implementations

impl Clone for Profile

fn clone(&self) -> Profile

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Profile

impl Debug for Profile

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

Formats the value using the given formatter.

impl Eq for Profile

impl PartialEq for Profile

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Profile