logos-storage/plonky2
1
0
Fork 0
mirror of https://github.com/logos-storage/plonky2.git synced 2026-01-09 09:13:09 +00:00
Code Issues Packages Projects Releases Wiki Activity

updated in line with main changes

Browse Source
This commit is contained in:
Nicholas Ward 2022-06-23 14:36:14 -07:00
parent 791b15f94f
commit 4a7ebf057b
3 changed files with 42 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

75
evm/src/all_stark.rs
View File

@ -71,14 +71,16 @@ mod tests {
use crate::all_stark::{AllStark, Table};
use crate::config::StarkConfig;
use crate::cpu::columns::{KECCAK_INPUT_LIMBS, KECCAK_OUTPUT_LIMBS, NUM_MEMORY_OPS};
use crate::cpu::cpu_stark::{self as cpu_stark_mod, CpuStark};
use crate::cross_table_lookup::{CrossTableLookup, TableWithColumns};
use crate::keccak::keccak_stark::{
self as keccak_stark_mod, KeccakStark, NUM_INPUTS, NUM_ROUNDS,
};
use crate::logic::{self, LogicStark};
use crate::cpu::columns::{KECCAK_INPUT_LIMBS, KECCAK_OUTPUT_LIMBS, NUM_MEMORY_OPS};
use crate::cross_table_lookup::{Column, CrossTableLookup, TableWithColumns};
use crate::memory::memory_stark::{generate_random_memory_ops, MemoryStark};
use crate::memory::memory_stark::{
self as memory_stark_mod, generate_random_memory_ops, MemoryStark,
};
use crate::proof::AllProof;
use crate::prover::prove;
use crate::recursive_verifier::{
@ -283,63 +285,6 @@ mod tests {
&mut memory_trace,
);
let mut cpu_keccak_input_output = cpu::columns::KECCAK_INPUT_LIMBS.collect::<Vec<_>>();
cpu_keccak_input_output.extend(cpu::columns::KECCAK_OUTPUT_LIMBS);
let mut keccak_keccak_input_output = (0..2 * NUM_INPUTS)
.map(keccak::registers::reg_input_limb)
.collect::<Vec<_>>();
keccak_keccak_input_output.extend(Column::singles(
(0..2 * NUM_INPUTS).map(keccak::registers::reg_output_limb),
));
let cpu_logic_input_output = {
let mut res = vec![
cpu::columns::IS_AND,
cpu::columns::IS_OR,
cpu::columns::IS_XOR,
];
res.extend(cpu::columns::LOGIC_INPUT0);
res.extend(cpu::columns::LOGIC_INPUT1);
res.extend(cpu::columns::LOGIC_OUTPUT);
res
};
let logic_logic_input_output = {
let mut res = vec![
logic::columns::IS_AND,
logic::columns::IS_OR,
logic::columns::IS_XOR,
];
res.extend(logic::columns::INPUT0_PACKED);
res.extend(logic::columns::INPUT1_PACKED);
res.extend(logic::columns::RESULT);
res
};
let cpu_memory_cols: Vec<Vec<_>> = (0..NUM_MEMORY_OPS)
.map(|op| {
let mut cols: Vec<Column<F>> = Column::singles([
cpu::columns::CLOCK,
cpu::columns::memop_is_read(op),
cpu::columns::memop_addr_context(op),
cpu::columns::memop_addr_segment(op),
cpu::columns::memop_addr_virtual(op),
])
.collect_vec();
cols.extend(Column::singles(
(0..8).map(|j| cpu::columns::memop_value(op, j)),
));
cols
})
.collect();
let mut memory_memory_cols = vec![
memory::registers::TIMESTAMP,
memory::registers::IS_READ,
memory::registers::ADDR_CONTEXT,
memory::registers::ADDR_SEGMENT,
memory::registers::ADDR_VIRTUAL,
];
memory_memory_cols.extend((0..8).map(memory::registers::value_limb));
let mut cross_table_lookups = vec![
CrossTableLookup::new(
vec![TableWithColumns::new(
@ -364,17 +309,17 @@ mod tests {
None,
),
];
cross_table_lookups.extend((0..1).map(|op| {
cross_table_lookups.extend((0..NUM_MEMORY_OPS).map(|op| {
CrossTableLookup::new(
vec![TableWithColumns::new(
Table::Cpu,
cpu_memory_cols[op].clone(),
Some(Column::single(cpu::columns::uses_memop(op))),
cpu_stark_mod::ctl_data_memory(op),
Some(cpu_stark_mod::ctl_filter_memory(op)),
)],
TableWithColumns::new(
Table::Memory,
Column::singles(memory_memory_cols.clone()).collect(),
Some(Column::single(memory::registers::is_memop(op))),
memory_stark_mod::ctl_data(),
Some(memory_stark_mod::ctl_filter(op)),
),
None,
)

24
evm/src/cpu/cpu_stark.rs
View File

@ -1,5 +1,6 @@
use std::marker::PhantomData;
use itertools::Itertools;
use plonky2::field::extension_field::{Extendable, FieldExtension};
use plonky2::field::field_types::Field;
use plonky2::field::packed_field::PackedField;
@ -23,11 +24,7 @@ pub fn ctl_filter_keccak<F: Field>() -> Column<F> {
}
pub fn ctl_data_logic<F: Field>() -> Vec<Column<F>> {
let mut res = vec![
Column::single(columns::IS_AND),
Column::single(columns::IS_OR),
Column::single(columns::IS_XOR),
];
let mut res = Column::singles([columns::IS_AND, columns::IS_OR, columns::IS_XOR]).collect_vec();
res.extend(columns::LOGIC_INPUT0.map(Column::single));
res.extend(columns::LOGIC_INPUT1.map(Column::single));
res.extend(columns::LOGIC_OUTPUT.map(Column::single));
@ -38,6 +35,23 @@ pub fn ctl_filter_logic<F: Field>() -> Column<F> {
Column::sum([columns::IS_AND, columns::IS_OR, columns::IS_XOR])
}
pub fn ctl_data_memory<F: Field>(op: usize) -> Vec<Column<F>> {
let mut cols: Vec<Column<F>> = Column::singles([
columns::CLOCK,
columns::memop_is_read(op),
columns::memop_addr_context(op),
columns::memop_addr_segment(op),
columns::memop_addr_virtual(op),
])
.collect_vec();
cols.extend(Column::singles((0..8).map(|j| columns::memop_value(op, j))));
cols
}
pub fn ctl_filter_memory<F: Field>(op: usize) -> Column<F> {
Column::single(columns::uses_memop(op))
}
#[derive(Copy, Clone)]
pub struct CpuStark<F, const D: usize> {
pub f: PhantomData<F>,

13
evm/src/memory/memory_stark.rs
View File

@ -3,6 +3,7 @@ use std::marker::PhantomData;
use itertools::{izip, multiunzip, Itertools};
use plonky2::field::extension_field::{Extendable, FieldExtension};
use plonky2::field::field_types::Field;
use plonky2::field::packed_field::PackedField;
use plonky2::field::polynomial::PolynomialValues;
use plonky2::hash::hash_types::RichField;
@ -12,6 +13,7 @@ use rand::Rng;
use super::registers::is_memop;
use crate::constraint_consumer::{ConstraintConsumer, RecursiveConstraintConsumer};
use crate::cross_table_lookup::Column;
use crate::lookup::{eval_lookups, eval_lookups_circuit, permuted_cols};
use crate::memory::registers::{
sorted_value_limb, value_limb, ADDR_CONTEXT, ADDR_SEGMENT, ADDR_VIRTUAL, CONTEXT_FIRST_CHANGE,
@ -26,6 +28,17 @@ use crate::vars::{StarkEvaluationTargets, StarkEvaluationVars};
pub(crate) const NUM_PUBLIC_INPUTS: usize = 0;
pub fn ctl_data<F: Field>() -> Vec<Column<F>> {
let mut res = Column::singles([TIMESTAMP, IS_READ, ADDR_CONTEXT, ADDR_SEGMENT, ADDR_VIRTUAL])
.collect_vec();
res.extend(Column::singles((0..8).map(value_limb)));
res
}
pub fn ctl_filter<F: Field>(op: usize) -> Column<F> {
Column::single(is_memop(op))
}
#[derive(Copy, Clone)]
pub struct MemoryStark<F, const D: usize> {
pub(crate) f: PhantomData<F>,