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

function API / remove redundancy

Browse Source
This commit is contained in:
Dmitry Vagner 2023-02-16 15:01:22 -08:00
parent 53ab0ada11
commit 4e4cfb06b3
3 changed files with 22 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
evm/src/cpu/kernel/interpreter.rs
View File

@ -65,30 +65,30 @@ pub fn run_interpreter(
) )
} }
pub struct InterpreterSetup { pub struct InterpreterMemoryInitialization {
pub label: String, pub label: String,
pub stack: Vec<U256>, pub stack: Vec<U256>,
pub segment: Segment, pub segment: Segment,
pub memory: Vec<(usize, Vec<U256>)>, pub memory: Vec<(usize, Vec<U256>)>,
} }
impl InterpreterSetup { pub fn run_interpreter_with_memory(
pub fn run(self) -> anyhow::Result<Interpreter<'static>> { memory_init: InterpreterMemoryInitialization,
let label = KERNEL.global_labels[&self.label]; ) -> anyhow::Result<Interpreter<'static>> {
let mut stack = self.stack; let label = KERNEL.global_labels[&memory_init.label];
stack.reverse(); let mut stack = memory_init.stack;
let mut interpreter = Interpreter::new_with_kernel(label, stack); stack.reverse();
for (pointer, data) in self.memory { let mut interpreter = Interpreter::new_with_kernel(label, stack);
for (i, term) in data.iter().enumerate() { for (pointer, data) in memory_init.memory {
interpreter for (i, term) in data.iter().enumerate() {
.generation_state interpreter.generation_state.memory.set(
.memory MemoryAddress::new(0, memory_init.segment, pointer + i),
.set(MemoryAddress::new(0, self.segment, pointer + i), *term) *term,
} )
} }
interpreter.run()?;
Ok(interpreter)
} }
interpreter.run()?;
Ok(interpreter)
} }
pub fn run<'a>( pub fn run<'a>(

10
evm/src/cpu/kernel/tests/hash.rs
View File

@ -5,7 +5,9 @@ use rand::{thread_rng, Rng};
use ripemd::{Digest, Ripemd160}; use ripemd::{Digest, Ripemd160};
use sha2::Sha256; use sha2::Sha256;
use crate::cpu::kernel::interpreter::InterpreterSetup; use crate::cpu::kernel::interpreter::{
run_interpreter_with_memory, InterpreterMemoryInitialization,
};
use crate::memory::segments::Segment::KernelGeneral; use crate::memory::segments::Segment::KernelGeneral;
/// Standard Blake2b implementation. /// Standard Blake2b implementation.
@ -40,8 +42,8 @@ fn make_interpreter_setup(
message: Vec<u8>, message: Vec<u8>,
hash_fn_label: &str, hash_fn_label: &str,
hash_input_virt: usize, hash_input_virt: usize,
) -> InterpreterSetup { ) -> InterpreterMemoryInitialization {
InterpreterSetup { InterpreterMemoryInitialization {
label: hash_fn_label.to_string(), label: hash_fn_label.to_string(),
stack: vec![ stack: vec![
U256::from(hash_input_virt), U256::from(hash_input_virt),
@ -75,7 +77,7 @@ fn prepare_test<T>(
let interpreter_setup = make_interpreter_setup(message, hash_fn_label, hash_input_virt); let interpreter_setup = make_interpreter_setup(message, hash_fn_label, hash_input_virt);
// Run the interpeter // Run the interpeter
let result = interpreter_setup.run().unwrap(); let result = run_interpreter_with_memory(interpreter_setup).unwrap();
Ok((expected, result.stack().to_vec())) Ok((expected, result.stack().to_vec()))
} }

35
evm/src/cpu/kernel/tests/test_utils.rs
View File

@ -1,35 +0,0 @@
use std::ops::Range;
use anyhow::Result;
use ethereum_types::U256;
use crate::cpu::kernel::aggregator::KERNEL;
use crate::cpu::kernel::interpreter::Interpreter;
use crate::memory::segments::Segment;
use crate::witness::memory::MemoryAddress;
pub struct InterpreterSetup {
pub label: String,
pub stack: Vec<U256>,
pub segment: Segment,
pub memory: Vec<(usize, Vec<U256>)>,
}
impl InterpreterSetup {
pub fn run(self) -> Result<Interpreter<'static>> {
let label = KERNEL.global_labels[&self.label];
let mut stack = self.stack;
stack.reverse();
let mut interpreter = Interpreter::new_with_kernel(label, stack);
for (pointer, data) in self.memory {
for (i, term) in data.iter().enumerate() {
interpreter
.generation_state
.memory
.set(MemoryAddress::new(0, self.segment, pointer + i), *term)
}
}
interpreter.run()?;
Ok(interpreter)
}
}