Struct CpuBackend 

pub struct CpuBackend<SC: StarkProtocolConfig>(/* private fields */);

Row-major CPU prover backend.

Uses RowMajorMatrix<SC::F> as the matrix type for better cache locality during constraint evaluation.

Implementations

impl<SC: StarkProtocolConfig> CpuBackend<SC>

pub fn new() -> Self

Trait Implementations

impl<SC: Clone + StarkProtocolConfig> Clone for CpuBackend<SC>

fn clone(&self) -> CpuBackend<SC>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<SC: Copy + StarkProtocolConfig> Copy for CpuBackend<SC>

impl<SC: StarkProtocolConfig> Default for CpuBackend<SC>

fn default() -> Self

Returns the “default value” for a type.

impl<SC: StarkProtocolConfig> DeviceDataTransporter<SC, CpuBackend<SC>> for CpuDevice<SC>

fn transport_pk_to_device( &self, mpk: &MultiStarkProvingKey<SC>, ) -> DeviceMultiStarkProvingKey<CpuBackend<SC>>

Transport the proving key to the device, filtering for only the provided air_ids.

fn transport_matrix_to_device( &self, matrix: &ColMajorMatrix<SC::F>, ) -> RowMajorMatrix<SC::F>

fn transport_pcs_data_to_device( &self, pcs_data: &StackedPcsData<SC::F, SC::Digest>, ) -> CpuStackedPcsData<SC::F, SC::Digest>

The commitment and prover_data are assumed to have been previously computed from the trace.

fn transport_matrix_from_device_to_host( &self, matrix: &RowMajorMatrix<SC::F>, ) -> ColMajorMatrix<SC::F>

Transport a device matrix to host. This should only be used for testing / debugging purposes.

fn transport_committed_trace_data_to_device( &self, committed_trace: &CommittedTraceData<CpuColMajorBackend<SC>>, ) -> CommittedTraceData<PB>

fn transport_proving_ctx_to_device( &self, ctx: &ProvingContext<CpuColMajorBackend<SC>>, ) -> ProvingContext<PB>

impl<SC, TS> MultiRapProver<CpuBackend<SC>, TS> for CpuDevice<SC>

where SC: StarkProtocolConfig, SC::EF: TwoAdicField + ExtensionField<SC::F>, TS: FiatShamirTranscript<SC>,

type PartialProof = (GkrProof<SC>, BatchConstraintProof<SC>)

The partial proof is the proof that the trace matrices satisfy all constraints assuming that certain polynomial opening claims are validated. In other words, it is a proof that reduces the constraint satisfaction claim to certain polynomial opening claims.

type Artifacts = Vec<<SC as StarkProtocolConfig>::EF>

Other artifacts of the proof (e.g., sampled randomness) that may be passed to later stages of the protocol.

type Error = CpuProverError

fn prove_rap_constraints( &self, transcript: &mut TS, mpk: &DeviceMultiStarkProvingKey<CpuBackend<SC>>, ctx: &ProvingContext<CpuBackend<SC>>, _common_main_pcs_data: &CpuStackedPcsData<SC::F, SC::Digest>, ) -> Result<((GkrProof<SC>, BatchConstraintProof<SC>), Vec<SC::EF>), Self::Error>

impl<SC, TS> OpeningProver<CpuBackend<SC>, TS> for CpuDevice<SC>

where SC: StarkProtocolConfig, SC::F: Ord, SC::EF: TwoAdicField + ExtensionField<SC::F> + Ord, TS: FiatShamirTranscript<SC>,

type OpeningProof = (StackingProof<SC>, WhirProof<SC>)

PCS opening proof on host. This should not be a reference.

type OpeningPoints = Vec<<SC as StarkProtocolConfig>::EF>

type Error = CpuProverError

Computes the opening proof. The common_main_pcs_data is the PcsData for the collection of common main trace matrices. It is owned by the function and may be mutated. The pre_cached_pcs_data_per_commit is the PcsData for the preprocessed and cached trace matrices. These are specified by their PcsData per commitment.

fn prove_openings( &self, transcript: &mut TS, mpk: &DeviceMultiStarkProvingKey<CpuBackend<SC>>, ctx: ProvingContext<CpuBackend<SC>>, common_main_pcs_data: CpuStackedPcsData<SC::F, SC::Digest>, r: Vec<SC::EF>, ) -> Result<(StackingProof<SC>, WhirProof<SC>), Self::Error>

impl<SC: StarkProtocolConfig> ProverBackend for CpuBackend<SC>

const CHALLENGE_EXT_DEGREE: u8

Extension field degree for the challenge field Self::Challenge over base field Self::Val.

type Val = <SC as StarkProtocolConfig>::F

Base field type, on host.

type Challenge = <SC as StarkProtocolConfig>::EF

Challenge field (extension field of base field), on host.

type Commitment = <SC as StarkProtocolConfig>::Digest

Single commitment on host.

type Matrix = DenseMatrix<<SC as StarkProtocolConfig>::F>

Single matrix buffer on device together with dimension metadata. Owning this means nothing else has a shared reference to the buffer.

type OtherAirData = ()

Backend specific type for any pre-computed data associated with a single AIR. For example, it may contain prover-specific precomputations based on the AIR constraints (but independent from any trace data).

type PcsData = CpuStackedPcsData<<SC as StarkProtocolConfig>::F, <SC as StarkProtocolConfig>::Digest>

Owned buffer for the preimage of a PCS commitment on device, together with any metadata necessary for computing opening proofs.

impl<SC, TS> ProverDevice<CpuBackend<SC>, TS> for CpuDevice<SC>

where SC: StarkProtocolConfig, SC::F: Ord, SC::EF: TwoAdicField + ExtensionField<SC::F> + Ord, TS: FiatShamirTranscript<SC>,

type Error = CpuProverError

type DeviceCtx = ()

Device-specific context (e.g., CUDA stream). Unit () for CPU devices.

fn device_ctx(&self) -> &()

impl<SC: StarkProtocolConfig> TraceCommitter<CpuBackend<SC>> for CpuDevice<SC>

where SC::F: Ord,

type Error = CpuProverError

fn commit( &self, traces: &[&RowMajorMatrix<SC::F>], ) -> Result<(SC::Digest, CpuStackedPcsData<SC::F, SC::Digest>), Self::Error>