Struct ProvingMemoryConfig 

pub struct ProvingMemoryConfig {
    pub base_field_size: usize,
    pub extension_degree: usize,
    pub log_blowup: usize,
    pub l_skip: usize,
    pub max_constraint_degree: usize,
    pub cache_rs_code_matrix: bool,
}

Configuration for proving memory estimates.

Fields

base_field_size: usize

Size of one base-field element in bytes.

extension_degree: usize

Degree of the extension field over the base field.

log_blowup: usize

-log_2 of the rate for the initial Reed-Solomon code.

l_skip: usize

log_2 of the univariate skip domain.

max_constraint_degree: usize

Maximum constraint degree across AIR and interaction constraints.

cache_rs_code_matrix: bool

Whether the prover keeps the Reed-Solomon code matrix cached after stacked_commit.

Implementations

impl ProvingMemoryConfig

pub fn from_protocol_config<SC: StarkProtocolConfig>( config: &SC, cache_rs_code_matrix: bool, ) -> Self

pub fn main_memory_bytes(&self, main_cells: usize) -> usize

pub fn rs_code_matrix_memory_bytes(&self, main_cells: usize) -> usize

pub fn main_cell_secondary_weight(&self) -> f64

pub fn main_secondary_memory_bytes_for_rot( &self, main_cells: usize, need_rot: bool, ) -> usize

Secondary memory for main_cells = Σ(padded_height * width).

mat_eval_bytes = (padded_height / 2^l_skip) * ((1 + need_rot) * width) * sizeof(EF)
               = (1 + need_rot) * main_cells * D_EF / 2^l_skip * sizeof(F)

interp_bytes      = (constraint_degree / 2) * mat_eval_bytes
secondary_bytes   = (1 + constraint_degree / 2) * mat_eval_bytes
secondary_weight  = (1 + constraint_degree / 2) * D_EF / 2^l_skip

AIRs with need_rot = true open two PCS cells per column.

pub fn main_secondary_memory_bytes(&self, counts: ProvingMemoryCounts) -> usize

pub fn interaction_memory_bytes_without_overhead( &self, interaction_cells: usize, ) -> usize

pub fn interaction_memory_bytes(&self, interaction_cells: usize) -> usize

pub fn estimate(&self, counts: ProvingMemoryCounts) -> ProvingMemoryEstimate

Convert main trace cells and interaction cells to memory bytes.

main_cells       = main_cells_with_rot + main_cells_without_rot
main             = main_cells * sizeof(F)
rs_code_matrix   = main_cells * 2^log_blowup * sizeof(F)
main_secondary   = sizeof(F) *
                   (2 * main_cell_secondary_weight() * main_cells_with_rot
                    + main_cell_secondary_weight() * main_cells_without_rot)
interaction      = sizeof(F) * interaction_cell_weight * interaction_cells
                   + INTERACTION_MEMORY_OVERHEAD

Cached RS code matrix:

total = main + rs_code_matrix + max(main_secondary, interaction)

Dropped RS code matrix:

total = main + max(rs_code_matrix, main_secondary, interaction)

Trait Implementations

impl Clone for ProvingMemoryConfig

fn clone(&self) -> ProvingMemoryConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ProvingMemoryConfig

impl Debug for ProvingMemoryConfig

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

Formats the value using the given formatter.

impl PartialEq for ProvingMemoryConfig

fn eq(&self, other: &ProvingMemoryConfig) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ProvingMemoryConfig