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

Merge pull request #587 from mir-protocol/s_columns_registers

Browse Source 
`registers` -> `columns`
This commit is contained in:
wborgeaud 2022-06-29 04:12:31 -05:00 committed by GitHub
commit 33cabb14de
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 36 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
evm/src/all_stark.rs
View File

@ -213,7 +213,7 @@ mod tests {
.map(|i| {
(0..2 * NUM_INPUTS)
.map(|j| {
keccak::registers::reg_input_limb(j)
keccak::columns::reg_input_limb(j)
.eval_table(keccak_trace, (i + 1) * NUM_ROUNDS - 1)
})
.collect::<Vec<_>>()
@ -225,7 +225,7 @@ mod tests {
.map(|i| {
(0..2 * NUM_INPUTS)
.map(|j| {
keccak_trace[keccak::registers::reg_output_limb(j)].values
keccak_trace[keccak::columns::reg_output_limb(j)].values
[(i + 1) * NUM_ROUNDS - 1]
})
.collect::<Vec<_>>()
@ -276,12 +276,12 @@ mod tests {
cpu_trace_rows.push(row);
}
let mut current_cpu_index = 0;
let mut last_timestamp = memory_trace[memory::registers::TIMESTAMP].values[0];
let mut last_timestamp = memory_trace[memory::columns::TIMESTAMP].values[0];
for i in 0..num_memory_ops {
let mem_timestamp = memory_trace[memory::registers::TIMESTAMP].values[i];
let mem_timestamp = memory_trace[memory::columns::TIMESTAMP].values[i];
let clock = mem_timestamp;
let op = (0..NUM_CHANNELS)
.filter(|&o| memory_trace[memory::registers::is_channel(o)].values[i] == F::ONE)
.filter(|&o| memory_trace[memory::columns::is_channel(o)].values[i] == F::ONE)
.collect_vec()[0];
if mem_timestamp != last_timestamp {
@ -292,16 +292,16 @@ mod tests {
cpu_trace_rows[current_cpu_index][cpu::columns::mem_channel_used(op)] = F::ONE;
cpu_trace_rows[current_cpu_index][cpu::columns::CLOCK] = clock;
cpu_trace_rows[current_cpu_index][cpu::columns::mem_is_read(op)] =
memory_trace[memory::registers::IS_READ].values[i];
memory_trace[memory::columns::IS_READ].values[i];
cpu_trace_rows[current_cpu_index][cpu::columns::mem_addr_context(op)] =
memory_trace[memory::registers::ADDR_CONTEXT].values[i];
memory_trace[memory::columns::ADDR_CONTEXT].values[i];
cpu_trace_rows[current_cpu_index][cpu::columns::mem_addr_segment(op)] =
memory_trace[memory::registers::ADDR_SEGMENT].values[i];
memory_trace[memory::columns::ADDR_SEGMENT].values[i];
cpu_trace_rows[current_cpu_index][cpu::columns::mem_addr_virtual(op)] =
memory_trace[memory::registers::ADDR_VIRTUAL].values[i];
memory_trace[memory::columns::ADDR_VIRTUAL].values[i];
for j in 0..8 {
cpu_trace_rows[current_cpu_index][cpu::columns::mem_value(op, j)] =
memory_trace[memory::registers::value_limb(j)].values[i];
memory_trace[memory::columns::value_limb(j)].values[i];
}
}
trace_rows_to_poly_values(cpu_trace_rows)

2
evm/src/keccak/registers.rs → evm/src/keccak/columns.rs
View File

@ -119,4 +119,4 @@ pub(crate) const fn reg_a_prime_prime_prime(x: usize, y: usize) -> usize {
}
}
pub(crate) const NUM_REGISTERS: usize = REG_A_PRIME_PRIME_PRIME_0_0_HI + 1;
pub(crate) const NUM_COLUMNS: usize = REG_A_PRIME_PRIME_PRIME_0_0_HI + 1;

26
evm/src/keccak/keccak_stark.rs
View File

@ -13,14 +13,14 @@ use plonky2::util::timing::TimingTree;
use crate::constraint_consumer::{ConstraintConsumer, RecursiveConstraintConsumer};
use crate::cross_table_lookup::Column;
use crate::keccak::columns::{
reg_a, reg_a_prime, reg_a_prime_prime, reg_a_prime_prime_0_0_bit, reg_a_prime_prime_prime,
reg_b, reg_c, reg_c_partial, reg_input_limb, reg_output_limb, reg_step, NUM_COLUMNS,
};
use crate::keccak::constants::{rc_value, rc_value_bit};
use crate::keccak::logic::{
andn, andn_gen, andn_gen_circuit, xor, xor3_gen, xor3_gen_circuit, xor_gen, xor_gen_circuit,
};
use crate::keccak::registers::{
reg_a, reg_a_prime, reg_a_prime_prime, reg_a_prime_prime_0_0_bit, reg_a_prime_prime_prime,
reg_b, reg_c, reg_c_partial, reg_input_limb, reg_output_limb, reg_step, NUM_REGISTERS,
};
use crate::keccak::round_flags::{eval_round_flags, eval_round_flags_recursively};
use crate::stark::Stark;
use crate::util::trace_rows_to_poly_values;
@ -55,7 +55,7 @@ impl<F: RichField + Extendable<D>, const D: usize> KeccakStark<F, D> {
pub(crate) fn generate_trace_rows(
&self,
inputs: Vec<[u64; NUM_INPUTS]>,
) -> Vec<[F; NUM_REGISTERS]> {
) -> Vec<[F; NUM_COLUMNS]> {
let num_rows = (inputs.len() * NUM_ROUNDS).next_power_of_two();
info!("{} rows", num_rows);
let mut rows = Vec::with_capacity(num_rows);
@ -71,8 +71,8 @@ impl<F: RichField + Extendable<D>, const D: usize> KeccakStark<F, D> {
rows
}
fn generate_trace_rows_for_perm(&self, input: [u64; NUM_INPUTS]) -> Vec<[F; NUM_REGISTERS]> {
let mut rows = vec![[F::ZERO; NUM_REGISTERS]; NUM_ROUNDS];
fn generate_trace_rows_for_perm(&self, input: [u64; NUM_INPUTS]) -> Vec<[F; NUM_COLUMNS]> {
let mut rows = vec![[F::ZERO; NUM_COLUMNS]; NUM_ROUNDS];
for x in 0..5 {
for y in 0..5 {
@ -92,11 +92,7 @@ impl<F: RichField + Extendable<D>, const D: usize> KeccakStark<F, D> {
rows
}
fn copy_output_to_input(
&self,
prev_row: [F; NUM_REGISTERS],
next_row: &mut [F; NUM_REGISTERS],
) {
fn copy_output_to_input(&self, prev_row: [F; NUM_COLUMNS], next_row: &mut [F; NUM_COLUMNS]) {
for x in 0..5 {
for y in 0..5 {
let cur_lo = prev_row[reg_a_prime_prime_prime(x, y)];
@ -117,7 +113,7 @@ impl<F: RichField + Extendable<D>, const D: usize> KeccakStark<F, D> {
}
}
fn generate_trace_row_for_round(&self, row: &mut [F; NUM_REGISTERS], round: usize) {
fn generate_trace_row_for_round(&self, row: &mut [F; NUM_COLUMNS], round: usize) {
row[reg_step(round)] = F::ONE;
// Populate C partial and C.
@ -219,7 +215,7 @@ impl<F: RichField + Extendable<D>, const D: usize> KeccakStark<F, D> {
}
impl<F: RichField + Extendable<D>, const D: usize> Stark<F, D> for KeccakStark<F, D> {
const COLUMNS: usize = NUM_REGISTERS;
const COLUMNS: usize = NUM_COLUMNS;
const PUBLIC_INPUTS: usize = NUM_PUBLIC_INPUTS;
fn eval_packed_generic<FE, P, const D2: usize>(
@ -529,8 +525,8 @@ mod tests {
use plonky2::field::types::Field;
use plonky2::plonk::config::{GenericConfig, PoseidonGoldilocksConfig};
use crate::keccak::columns::reg_output_limb;
use crate::keccak::keccak_stark::{KeccakStark, NUM_INPUTS, NUM_ROUNDS};
use crate::keccak::registers::reg_output_limb;
use crate::stark_testing::{test_stark_circuit_constraints, test_stark_low_degree};
#[test]

2
evm/src/keccak/mod.rs
View File

@ -1,5 +1,5 @@
pub mod columns;
pub mod constants;
pub mod keccak_stark;
pub mod logic;
pub mod registers;
pub mod round_flags;

8
evm/src/keccak/round_flags.rs
View File

@ -5,14 +5,14 @@ use plonky2::hash::hash_types::RichField;
use plonky2::plonk::circuit_builder::CircuitBuilder;
use crate::constraint_consumer::{ConstraintConsumer, RecursiveConstraintConsumer};
use crate::keccak::columns::reg_step;
use crate::keccak::columns::NUM_COLUMNS;
use crate::keccak::keccak_stark::{NUM_PUBLIC_INPUTS, NUM_ROUNDS};
use crate::keccak::registers::reg_step;
use crate::keccak::registers::NUM_REGISTERS;
use crate::vars::StarkEvaluationTargets;
use crate::vars::StarkEvaluationVars;
pub(crate) fn eval_round_flags<F: Field, P: PackedField<Scalar = F>>(
vars: StarkEvaluationVars<F, P, NUM_REGISTERS, NUM_PUBLIC_INPUTS>,
vars: StarkEvaluationVars<F, P, NUM_COLUMNS, NUM_PUBLIC_INPUTS>,
yield_constr: &mut ConstraintConsumer<P>,
) {
// Initially, the first step flag should be 1 while the others should be 0.
@ -30,7 +30,7 @@ pub(crate) fn eval_round_flags<F: Field, P: PackedField<Scalar = F>>(
pub(crate) fn eval_round_flags_recursively<F: RichField + Extendable<D>, const D: usize>(
builder: &mut CircuitBuilder<F, D>,
vars: StarkEvaluationTargets<D, NUM_REGISTERS, NUM_PUBLIC_INPUTS>,
vars: StarkEvaluationTargets<D, NUM_COLUMNS, NUM_PUBLIC_INPUTS>,
yield_constr: &mut RecursiveConstraintConsumer<F, D>,
) {
let one = builder.one_extension();

2
evm/src/memory/registers.rs → evm/src/memory/columns.rs
View File

@ -52,4 +52,4 @@ pub(crate) const fn is_channel(channel: usize) -> usize {
IS_CHANNEL_START + channel
}
pub(crate) const NUM_REGISTERS: usize = IS_CHANNEL_START + NUM_CHANNELS;
pub(crate) const NUM_COLUMNS: usize = IS_CHANNEL_START + NUM_CHANNELS;

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

@ -11,13 +11,13 @@ use plonky2::timed;
use plonky2::util::timing::TimingTree;
use rand::Rng;
use super::registers::is_channel;
use super::columns::is_channel;
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::{
use crate::memory::columns::{
sorted_value_limb, value_limb, ADDR_CONTEXT, ADDR_SEGMENT, ADDR_VIRTUAL, CONTEXT_FIRST_CHANGE,
COUNTER, COUNTER_PERMUTED, IS_READ, NUM_REGISTERS, RANGE_CHECK, RANGE_CHECK_PERMUTED,
COUNTER, COUNTER_PERMUTED, IS_READ, NUM_COLUMNS, RANGE_CHECK, RANGE_CHECK_PERMUTED,
SEGMENT_FIRST_CHANGE, SORTED_ADDR_CONTEXT, SORTED_ADDR_SEGMENT, SORTED_ADDR_VIRTUAL,
SORTED_IS_READ, SORTED_TIMESTAMP, TIMESTAMP, VIRTUAL_FIRST_CHANGE,
};
@ -227,10 +227,10 @@ impl<F: RichField + Extendable<D>, const D: usize> MemoryStark<F, D> {
pub(crate) fn generate_trace_rows(
&self,
memory_ops: Vec<MemoryOp<F>>,
) -> Vec<[F; NUM_REGISTERS]> {
) -> Vec<[F; NUM_COLUMNS]> {
let num_ops = memory_ops.len();
let mut trace_cols = [(); NUM_REGISTERS].map(|_| vec![F::ZERO; num_ops]);
let mut trace_cols = [(); NUM_COLUMNS].map(|_| vec![F::ZERO; num_ops]);
for i in 0..num_ops {
let MemoryOp {
channel_index,
@ -254,7 +254,7 @@ impl<F: RichField + Extendable<D>, const D: usize> MemoryStark<F, D> {
self.generate_memory(&mut trace_cols);
let mut trace_rows = vec![[F::ZERO; NUM_REGISTERS]; num_ops];
let mut trace_rows = vec![[F::ZERO; NUM_COLUMNS]; num_ops];
for (i, col) in trace_cols.iter().enumerate() {
for (j, &val) in col.iter().enumerate() {
trace_rows[j][i] = val;
@ -353,7 +353,7 @@ impl<F: RichField + Extendable<D>, const D: usize> MemoryStark<F, D> {
}
impl<F: RichField + Extendable<D>, const D: usize> Stark<F, D> for MemoryStark<F, D> {
const COLUMNS: usize = NUM_REGISTERS;
const COLUMNS: usize = NUM_COLUMNS;
const PUBLIC_INPUTS: usize = NUM_PUBLIC_INPUTS;
fn eval_packed_generic<FE, P, const D2: usize>(

2
evm/src/memory/mod.rs
View File

@ -1,5 +1,5 @@
pub mod columns;
pub mod memory_stark;
pub mod registers;
pub(crate) const NUM_CHANNELS: usize = 4;
pub(crate) const VALUE_LIMBS: usize = 8;