Struct CpuLayerExecutor

pub struct CpuLayerExecutor<F>(/* private fields */);

Trait Implementations

impl<F: TowerTop> ComputeLayerExecutor<F> for CpuLayerExecutor<F>

type OpValue = F

The operation (scalar) value type.

type ExprEval = ArithCircuit<F>

The evaluator for arithmetic expressions (polynomials).

type KernelExec = CpuKernelBuilder

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

type DevMem = CpuMemory

The device memory.

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

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

fn map_kernels( &mut self, map: impl Sync + for<'a> Fn(&'a mut Self::KernelExec, usize, Vec<KernelBuffer<'a, F, Self::DevMem>>) -> Result<(), Error>, mem_maps: Vec<KernelMemMap<'_, F, Self::DevMem>>, ) -> Result<(), Error>

Launch many kernels in parallel to process buffers without accumulating results.

fn inner_product<'a>( &'a mut self, a_in: SubfieldSlice<'_, F, Self::DevMem>, b_in: &'a [F], ) -> Result<F, Error>

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

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

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

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

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

fn tensor_expand( &mut self, log_n: usize, coordinates: &[F], data: &mut &mut [F], ) -> Result<(), Error>

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

fn fri_fold<FSub>( &mut self, ntt: &(impl AdditiveNTT<FSub> + Sync), log_len: usize, log_batch_size: usize, challenges: &[F], data_in: &[F], data_out: &mut &mut [F], ) -> Result<(), Error>

where FSub: BinaryField, F: ExtensionField<FSub>,

FRI-fold the interleaved codeword using the given challenges.

fn extrapolate_line( &mut self, evals_0: &mut &mut [F], evals_1: &[F], z: F, ) -> 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<F>>::FSlice<'_>>, output: &mut <Self::DevMem as ComputeMemory<F>>::FSliceMut<'_>, composition: &Self::ExprEval, ) -> Result<(), Error>

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

fn pairwise_product_reduce( &mut self, input: <Self::DevMem as ComputeMemory<F>>::FSlice<'_>, round_outputs: &mut [<Self::DevMem as ComputeMemory<F>>::FSliceMut<'_>], ) -> Result<(), Error>

Reduces a slice of elements to a single value by recursively applying pairwise multiplication.

fn join<Out1: Send, Out2: Send>( &mut self, op1: impl Send + FnOnce(&mut Self) -> Result<Out1, Error>, op2: impl Send + 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: Send, I: ExactSizeIterator<Item: Send> + Send>( &mut self, iter: I, map: impl Sync + Fn(&mut Self, I::Item) -> Result<Out, Error>, ) -> Result<Vec<Out>, Error>

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

impl<F: Debug> Debug for CpuLayerExecutor<F>

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

Formats the value using the given formatter.

impl<F> Default for CpuLayerExecutor<F>

fn default() -> Self

Returns the “default value” for a type.