Enum ScratchRequirement 

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

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.

Affine

At most base_bytes + bytes_per_element * elements + bytes_per_worker * workers of scratch, where workers is the number of threads the operation may run on.

For an operation whose scratch is not purely per element: a fixed setup cost dominates small inputs, and a threaded operation pays per worker (pool bookkeeping, work stolen onto another thread being live at the same time as the rest) no matter how small the input is (#226). A Self::PerElement bound tight enough for large inputs is then below the real peak for small ones.

Fields

base_bytes: usize

Upper bound independent of input size and worker count, in bytes.

bytes_per_element: usize

Upper bound per input element, in bytes.

bytes_per_worker: usize

Upper bound per worker thread, in bytes. Zero for an operation that never runs on more than the calling thread.

Implementations

impl ScratchRequirement

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

Upper bound for elements inputs, or None when unbounded.

An Self::Affine requirement with a per-worker term has no bound without a worker count, so it reports None here; use Self::upper_bound_bytes_on.

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

Upper bound for elements inputs run on workers threads, or None when unbounded or when the bound overflows usize.

Only Self::Affine depends on workers.

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. A per-worker term is charged for Parallelism::worker_bound of options’ parallelism; a caller that knows the operation runs on a different number of threads uses Self::fits_budget_on.

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.

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

Whether this requirement fits options’ memory budget for elements run on workers threads.

For a caller that knows the width the operation actually runs on: a dispatcher scoping the call to its own pool, or a provider checking the pool it finds itself in.

Trait Implementations

impl Clone for ScratchRequirement

fn clone(&self) -> ScratchRequirement

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ScratchRequirement

impl Debug for ScratchRequirement

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

Formats the value using the given formatter.

impl Eq for ScratchRequirement

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ScratchRequirement