Struct FastCpuExecutor

pub struct FastCpuExecutor<'a, T: TowerFamily, P: PackedTop<T>> { /* private fields */ }

Implementations

impl<'a, T: TowerFamily, P: PackedTop<T>> FastCpuExecutor<'a, T, P>

pub fn new(kernel_buffers: &'a ThreadLocal<RefCell<Vec<P>>>) -> Self

Trait Implementations

impl<'a, T: TowerFamily, P: PackedTop<T>> ComputeLayerExecutor<<T as TowerFamily>::B128> for FastCpuExecutor<'a, T, P>

type KernelExec = FastKernelBuilder<T, P>

The executor that can execute operations on a kernel-level granularity (i.e., a single core).

type DevMem = PackedMemory<P>

The device memory.

type OpValue = <T as TowerFamily>::B128

The operation (scalar) value type.

type ExprEval = ArithCircuitPoly<<T as TowerFamily>::B128>

The evaluator for arithmetic expressions (polynomials).

fn inner_product( &mut self, a_in: SubfieldSlice<'_, T::B128, Self::DevMem>, b_in: <Self::DevMem as ComputeMemory<T::B128>>::FSlice<'_>, ) -> Result<Self::OpValue, Error>

Returns the inner product of a vector of subfield elements with big field elements.

fn tensor_expand( &mut self, log_n: usize, coordinates: &[T::B128], data: &mut <Self::DevMem as ComputeMemory<T::B128>>::FSliceMut<'_>, ) -> Result<(), Error>

Computes the iterative tensor product of the input with the given coordinates.

fn accumulate_kernels( &mut self, map: impl Sync + for<'b> Fn(&'b mut Self::KernelExec, usize, Vec<KernelBuffer<'b, T::B128, Self::DevMem>>) -> Result<Vec<T::B128>, Error>, mem_maps: Vec<KernelMemMap<'_, T::B128, Self::DevMem>>, ) -> Result<Vec<Self::OpValue>, Error>

Launch many kernels in parallel and accumulate the scalar results with field addition.

fn fold_left( &mut self, mat: SubfieldSlice<'_, T::B128, Self::DevMem>, vec: <Self::DevMem as ComputeMemory<T::B128>>::FSlice<'_>, out: &mut <Self::DevMem as ComputeMemory<T::B128>>::FSliceMut<'_>, ) -> Result<(), Error>

Computes left matrix-vector multiplication of a subfield matrix with a big field vector.

fn fold_right( &mut self, mat: SubfieldSlice<'_, T::B128, Self::DevMem>, vec: <Self::DevMem as ComputeMemory<T::B128>>::FSlice<'_>, out: &mut <Self::DevMem as ComputeMemory<T::B128>>::FSliceMut<'_>, ) -> Result<(), Error>

Computes right matrix-vector multiplication of a subfield matrix with a big field vector.

fn fri_fold<FSub>( &mut self, ntt: &(impl AdditiveNTT<FSub> + Sync), log_len: usize, log_batch_size: usize, challenges: &[T::B128], data_in: <Self::DevMem as ComputeMemory<T::B128>>::FSlice<'_>, data_out: &mut <Self::DevMem as ComputeMemory<T::B128>>::FSliceMut<'_>, ) -> Result<(), Error>

where FSub: BinaryField, T::B128: ExtensionField<FSub>,

FRI-fold the interleaved codeword using the given challenges.

fn extrapolate_line( &mut self, evals_0: &mut <Self::DevMem as ComputeMemory<T::B128>>::FSliceMut<'_>, evals_1: <Self::DevMem as ComputeMemory<T::B128>>::FSlice<'_>, z: T::B128, ) -> Result<(), Error>

Extrapolates a line between a vector of evaluations at 0 and evaluations at 1.

fn compute_composite( &mut self, inputs: &SlicesBatch<<Self::DevMem as ComputeMemory<T::B128>>::FSlice<'_>>, output: &mut <Self::DevMem as ComputeMemory<T::B128>>::FSliceMut<'_>, composition: &ArithCircuitPoly<T::B128>, ) -> Result<(), Error>

Computes the elementwise application of a compiled arithmetic expression to multiple input slices.

fn join<Out1, Out2>( &mut self, op1: impl FnOnce(&mut Self) -> Result<Out1, Error>, op2: impl FnOnce(&mut Self) -> Result<Out2, Error>, ) -> Result<(Out1, Out2), Error>

Creates an operation that depends on the concurrent execution of two inner operations.

fn map<Out, I>( &mut self, iter: I, map: impl Fn(&mut Self, <I as Iterator>::Item) -> Result<Out, Error>, ) -> Result<Vec<Out>, Error>

where I: ExactSizeIterator,

Creates an operation that depends on the concurrent execution of a sequence of operations.