Struct Resumable 

pub struct Resumable<T>(/* private fields */);

Implementations

impl<T> Resumable<T>

pub fn new(val: T) -> Self

pub fn consume(self) -> T

Trait Implementations

impl<T: Clone> Clone for Resumable<T>

fn clone(&self) -> Resumable<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Resumable<T>

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

Formats the value using the given formatter.

impl<T, U, R, A> SIMDSchema<T, U, A> for Resumable<R>

where A: Architecture, R: ResumableSIMDSchema<T, U, A>,

type SIMDWidth = <<R as ResumableSIMDSchema<T, U, A>>::NonResumable as SIMDSchema<T, U, A>>::SIMDWidth

The desired SIMD read width. Reads from the input slice will be use this stride when accessing memory.

type Accumulator = <<R as ResumableSIMDSchema<T, U, A>>::NonResumable as SIMDSchema<T, U, A>>::Accumulator

The type used to represent partial accumulated values.

type Left = <<R as ResumableSIMDSchema<T, U, A>>::NonResumable as SIMDSchema<T, U, A>>::Left

The type used for the left-hand side.

type Right = <<R as ResumableSIMDSchema<T, U, A>>::NonResumable as SIMDSchema<T, U, A>>::Right

The type used for the right-hand side.

type Return = Resumable<R>

The final return type. This is often f32 for complete distance functions, but need not always be.

type Main = <<R as ResumableSIMDSchema<T, U, A>>::NonResumable as SIMDSchema<T, U, A>>::Main

The implementation of the main loop.

fn init(&self, arch: A) -> Self::Accumulator

Initialize an empty (identity) accumulator.

fn accumulate( &self, x: Self::Left, y: Self::Right, acc: Self::Accumulator, ) -> Self::Accumulator

Perform an accumulation.

fn combine( &self, x: Self::Accumulator, y: Self::Accumulator, ) -> Self::Accumulator

Combine two independent accumulators (allows for unrolling).

fn reduce(&self, x: Self::Accumulator) -> Self::Return

Perform a reduction on the accumulator to yield the final result.

unsafe fn epilogue( &self, arch: A, x: *const T, y: *const U, len: usize, acc: Self::Accumulator, ) -> Self::Accumulator

A supplied trait for dealing with non-full-width epilogues. Often, masked based loading will do the right thing, but for architectures like AVX2 that have limited support for masking 8 and 16-bit operations, using a scalar fallback may just be better.

fn get_simd_width() -> usize

!! Do not extend this function !!

fn get_main_bocksize() -> usize

!! Do not extend this function !!

impl<T: Copy> Copy for Resumable<T>