Enum Operation 

pub enum Operation {
    StoreNoEmbedding,
    SearchFts,
    RecallHot,
    KgQueryDepth1,
    KgQueryDepth3,
    KgQueryDepth5,
    KgTimeline,
}

Hot-path operations covered by this iteration of the bench tool.

Variants

StoreNoEmbedding

memory_store without embedding — pure SQLite write path.

SearchFts

memory_search — FTS5 keyword baseline.

RecallHot

memory_recall hot path, depth=1 (no hierarchy expansion).

KgQueryDepth1

memory_kg_query recursive-CTE traversal at depth=1 (the shallowest path through the depth ≤ 3 budget bucket).

KgQueryDepth3

memory_kg_query recursive-CTE traversal at depth=3 (the deepest path inside the “depth ≤ 3” 100 ms budget bucket). Driven against a chain fixture so the recursive CTE actually visits three hops per query.

KgQueryDepth5

memory_kg_query recursive-CTE traversal at depth=5 (the tail case for the “depth ≤ 5” 250 ms budget bucket). Driven against the same chain fixture as depth=3.

KgTimeline

memory_kg_timeline — ordered timeline for a single source.

Implementations

impl Operation

pub fn label(self) -> &'static str

pub fn target_p95_ms(self) -> f64

p95 budget in milliseconds, sourced from PERFORMANCE.md.

KgQueryDepth1 and KgQueryDepth3 both fall in the “depth ≤ 3” (100 ms) bucket; KgQueryDepth5 is the tail case at “depth ≤ 5” (250 ms). SearchFts and KgTimeline happen to share the same numeric budget as the depth ≤ 3 bucket despite belonging to different table rows in PERFORMANCE.md.

This is the canonical published budget; the runner-effective pass/fail verdict uses [effective_target_p95_ms] which applies the MACOS_BUDGET_MULT platform multiplier on top.

pub fn effective_target_p95_ms(self) -> f64

Runner-effective p95 budget — equal to [target_p95_ms] on Linux/Windows, but multiplied by MACOS_BUDGET_MULT on macOS targets per issue #1193. The pass/fail verdict in the CLI bench tool uses this value; the JSON envelope’s target_p95_ms field continues to report the canonical PERFORMANCE.md number so regression dashboards stay stable.

pub fn target_p95_ms_at_scale(self, scale: Option<usize>) -> f64

#1579 B8 — canonical p95 budget at a given corpus scale. None (the default workload) keeps the legacy Self::target_p95_ms budgets byte-for-byte. Some(rows) swaps in the SCALE_BUDGETS row for the three corpus-sensitive operations; the KG operations keep their canonical budgets because their fixtures are scale-independent (see ScaleBudgets).

pub fn effective_target_p95_ms_at_scale(self, scale: Option<usize>) -> f64

#1579 B8 — runner-effective sibling of Self::target_p95_ms_at_scale (applies the #1193 macOS multiplier, same as Self::effective_target_p95_ms).

Trait Implementations

impl Clone for Operation

fn clone(&self) -> Operation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Operation

impl Debug for Operation

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Operation

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Operation

impl PartialEq for Operation

fn eq(&self, other: &Operation) -> 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 Serialize for Operation

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Operation