Struct ProtocolParams 

pub struct ProtocolParams {
    pub window_ms: u64,
    pub warmup_requests_per_worker: u32,
    pub quiesce_ms: u64,
    pub cooldown_ms: u64,
    pub n_predict: u32,
    pub replicates: u32,
    pub interleaved: bool,
    pub sampler: Sampler,
}

§5.1 — the protocol block, read from perf-matrix.yaml and emitted verbatim at the receipt’s top level as protocol.

A reader that cannot see the window, the warmup, the cooldown, the sampler and the replicate count cannot tell a 60 s conformant band from a 5 s one, and two receipts written under different protocols are not comparable — which is why the whole block is also in the PP-22 join key.

Fields

window_ms: u64

T — the measurement window, in milliseconds.

warmup_requests_per_worker: u32

Warmup requests per worker, discarded (§4.4.2’s 2 × c as a per-worker count, so the band-level figure is warmup_requests_per_worker × c).

quiesce_ms: u64

Quiesce between warmup completion and the first sampled request.

cooldown_ms: u64

§5.1 — cooldown between the two lanes of an interleaved replicate.

n_predict: u32

Generated tokens per request (max_tokens on the wire).

replicates: u32

Replicates per cell. The matrix declares the FLOOR (replicates_min); a receipt records the number actually run and is NONCONFORMANT-VALID below it.

interleaved: bool

Whether the replicates alternated A,B,A,B,….

sampler: Sampler

The pinned sampler (PP-28).

Implementations

impl ProtocolParams

pub const fn spec_fallback() -> Self

The spec literals, as a documented fallback for tests and for callers that must render a receipt before the matrix carries a protocol: block.

Never reached silently by Self::from_matrix, which returns Err.

pub fn from_matrix() -> Result<Self, String>

Read the protocol: block out of the compiled-in perf-matrix.yaml.

Errors

When the file does not parse as YAML, or when it carries no protocol: block, or when the block is missing a key. The error NAMES the missing thing: a protocol silently defaulted to the Rust consts is exactly the drift PP-33 exists to prevent.

pub fn from_matrix_source(source: &str) -> Result<Self, String>

Self::from_matrix against an explicit document, so a test can feed a matrix that differs from the shipped one.

Errors

As Self::from_matrix.

pub fn effective_with_source() -> (Self, ProtocolSource)

The parameters a receipt written on this checkout must use, with the provenance of where they came from.

Self::from_matrix is the honest reader and returns Err; this is the one place the fallback is taken, and the returned ProtocolSource is what the producer prints once and — on the fallback — names in unproduced_fields.

The silent version of this (Self::effective, which discarded the error) put the Rust consts on the wire under a protocol: block the receipt then claimed came from the matrix. PP-33’s whole point is that every gated number lives in perf-matrix.yaml; a receipt that quietly substituted a compiled-in copy is the drift it exists to prevent, and it was invisible because nothing ever called source().

pub fn effective() -> Self

Self::effective_with_source without the provenance, for callers that record it separately (the CLI producer) or do not write a receipt at all (tests, BandConfig).

pub fn source() -> Result<&'static str, String>

"perf-matrix.yaml" when the matrix declares a protocol: block, and the reason the fallback was taken otherwise.

Errors

When the matrix has no protocol: block; the error is the provenance note a caller puts in unproduced_fields.

Trait Implementations

impl Clone for ProtocolParams

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 ProtocolParams

impl Debug for ProtocolParams

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ProtocolParams

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ProtocolParams

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for ProtocolParams

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 ProtocolParams