Enum ScratchRequirement

#[non_exhaustive]
pub enum ScratchRequirement {
    None,
    Fixed {
        bytes: usize,
    },
    PerElement {
        bytes_per_element: usize,
    },
    Unbounded,
}

Scratch memory an operation needs beyond its inputs and outputs.

Declared up front so a caller can budget, pre-reserve, or refuse before any work starts. Unbounded is deliberately representable and deliberately unpleasant: an operation that cannot bound its scratch must say so rather than allocating silently in a hot loop.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

None

Operates in place; no scratch beyond inputs and outputs.

Fixed

At most bytes of scratch, independent of input size.

Fields

bytes: usize

Upper bound in bytes.

PerElement

At most bytes_per_element * elements of scratch.

Fields

bytes_per_element: usize

Upper bound per input element, in bytes.

Unbounded

Scratch cannot be bounded ahead of time.

Callers must treat this as “may allocate arbitrarily”; a memory budget cannot be enforced against it.

Implementations

impl ScratchRequirement

pub const fn upper_bound_bytes(self, elements: usize) -> Option<usize>

Upper bound for elements inputs, or None when unbounded.

pub fn fits_budget(self, options: &ExecutionOptions, elements: usize) -> bool

Whether this requirement fits options’ memory budget for elements.

An unbounded requirement never fits a declared budget: allowing it would make the budget advisory, which is the failure this type exists to stop. Whether this requirement fits the caller’s memory budget.

No longer const: it reads an ExecutionOptions that now owns a shared cancellation handle, so it cannot be destructured at compile time. Budget checks happen once per dispatch, not on a hot path.

Trait Implementations

impl Clone for ScratchRequirement

fn clone(&self) -> ScratchRequirement

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ScratchRequirement

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

Formats the value using the given formatter.

impl Hash for ScratchRequirement

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ScratchRequirement

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

impl Eq for ScratchRequirement

impl StructuralPartialEq for ScratchRequirement