Scroll dev 0830 (v2.0.0)

crates/core/executor/src/events/memcpy.rs

@@ -0,0 +1,14 @@
+use super::{LookupId, MemoryReadRecord, MemoryWriteRecord};
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct MemCopyEvent {
+    pub lookup_id: LookupId,
+    pub shard: u32,
+    pub channel: u8,
+    pub clk: u32,
+    pub src_ptr: u32,
+    pub dst_ptr: u32,
+    pub read_records: Vec<MemoryReadRecord>,
+    pub write_records: Vec<MemoryWriteRecord>,
+}

crates/core/executor/src/events/mod.rs

@@ -3,13 +3,15 @@
 mod alu;
 mod byte;
 mod cpu;
+mod memcpy;
 mod memory;
 mod precompiles;
 mod utils;
 
 pub use alu::*;
 pub use byte::*;
 pub use cpu::*;
+pub use memcpy::*;
 pub use memory::*;
 pub use precompiles::*;
 pub use utils::*;

crates/core/executor/src/events/precompiles/bn254_scalar.rs

@@ -0,0 +1,167 @@
+/*
+use crate::{
+    operations::field::params::{FieldParameters, NumWords},
+    operations::field::{field_op::FieldOperation, params::Limbs},
+    runtime::{MemoryReadRecord, MemoryWriteRecord, SyscallContext},
+};
+*/
+use num::BigUint;
+use sp1_curves::{
+    params::{FieldParameters, NumWords},
+    weierstrass::bn254::Bn254ScalarField,
+};
+use typenum::Unsigned;
+
+use serde::{Deserialize, Serialize};
+
+use crate::{
+    events::{LookupId, MemoryReadRecord, MemoryWriteRecord},
+    syscalls::SyscallContext,
+};
+
+use super::FieldOperation;
+
+pub const NUM_WORDS_PER_FE: usize = 8;
+
+#[derive(PartialEq, Copy, Clone, Debug, Serialize, Deserialize)]
+pub enum Bn254FieldOperation {
+    Mul = 2,
+    Mac = 4,
+}
+
+impl Bn254FieldOperation {
+    pub const fn to_field_operation(&self) -> FieldOperation {
+        match self {
+            Bn254FieldOperation::Mul => FieldOperation::Mul,
+            Bn254FieldOperation::Mac => panic!("not supported"),
+        }
+    }
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct Bn254FieldArithEvent {
+    pub lookup_id: LookupId,
+    pub shard: u32,
+    pub channel: u8,
+    pub clk: u32,
+    pub op: Bn254FieldOperation,
+    pub arg1: FieldArithMemoryAccess<MemoryWriteRecord>,
+    pub arg2: FieldArithMemoryAccess<MemoryReadRecord>,
+    pub a: Option<FieldArithMemoryAccess<MemoryReadRecord>>,
+    pub b: Option<FieldArithMemoryAccess<MemoryReadRecord>>,
+}
+
+pub fn create_bn254_scalar_arith_event(
+    rt: &mut SyscallContext,
+    arg1: u32,
+    arg2: u32,
+    op: Bn254FieldOperation,
+) -> Bn254FieldArithEvent {
+    let start_clk = rt.clk;
+    let p_ptr = arg1;
+    let q_ptr = arg2;
+
+    assert_eq!(p_ptr % 4, 0, "p_ptr({:x}) is not aligned", p_ptr);
+    assert_eq!(q_ptr % 4, 0, "q_ptr({:x}) is not aligned", q_ptr);
+
+    let nw_per_fe = <Bn254ScalarField as NumWords>::WordsFieldElement::USIZE;
+    debug_assert_eq!(nw_per_fe, NUM_WORDS_PER_FE);
+
+    let arg1: Vec<u32> = rt.slice_unsafe(p_ptr, nw_per_fe);
+    let arg2 = match op {
+        Bn254FieldOperation::Mac => FieldArithMemoryAccess::read(rt, arg2, 2),
+        _ => FieldArithMemoryAccess::read(rt, arg2, nw_per_fe),
+    };
+
+    let bn_arg1 = BigUint::from_bytes_le(
+        &arg1.iter().copied().flat_map(|word| word.to_le_bytes()).collect::<Vec<u8>>(),
+    );
+    let modulus = Bn254ScalarField::modulus();
+
+    let (a, b, bn_arg1_out) = if matches!(op, Bn254FieldOperation::Mac) {
+        let a = FieldArithMemoryAccess::read(rt, arg2.memory_records[0].value, nw_per_fe);
+        let b = FieldArithMemoryAccess::read(rt, arg2.memory_records[1].value, nw_per_fe);
+
+        let bn_a = a.value_as_biguint();
+        let bn_b = b.value_as_biguint();
+        let bn_arg1_out = (&bn_a * &bn_b + &bn_arg1) % modulus;
+
+        (Some(a), Some(b), bn_arg1_out)
+    } else {
+        let bn_arg2 = arg2.value_as_biguint();
+
+        let bn_arg1_out = match op {
+            Bn254FieldOperation::Mul => (&bn_arg1 * &bn_arg2) % modulus,
+            _ => unimplemented!("not supported"),
+        };
+        (None, None, bn_arg1_out)
+    };
+
+    log::trace!(
+        "shard: {}, clk: {}, op: {:?}, arg1: {:?}, arg2: {:?}, a: {:?}, b: {:?}",
+        rt.current_shard(),
+        rt.clk,
+        op,
+        arg1,
+        arg2,
+        a,
+        b
+    );
+
+    let mut result_words = bn_arg1_out.to_u32_digits();
+    result_words.resize(nw_per_fe, 0);
+
+    let arg1 = FieldArithMemoryAccess::write(rt, p_ptr, &result_words);
+
+    let shard = rt.current_shard();
+    Bn254FieldArithEvent {
+        lookup_id: rt.syscall_lookup_id,
+        shard,
+        channel: rt.current_channel(),
+        clk: start_clk,
+        op,
+        arg1,
+        arg2,
+        a,
+        b,
+    }
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct FieldArithMemoryAccess<T> {
+    pub ptr: u32,
+    pub memory_records: Vec<T>,
+}
+
+impl FieldArithMemoryAccess<MemoryReadRecord> {
+    pub fn read(rt: &mut SyscallContext, ptr: u32, len: usize) -> Self {
+        let (memory_records, _) = rt.mr_slice(ptr, len);
+        Self { ptr, memory_records }
+    }
+
+    pub fn value_as_biguint(&self) -> BigUint {
+        BigUint::from_bytes_le(
+            &self
+                .memory_records
+                .iter()
+                .flat_map(|word| word.value.to_le_bytes())
+                .collect::<Vec<u8>>(),
+        )
+    }
+}
+
+impl FieldArithMemoryAccess<MemoryWriteRecord> {
+    pub fn write(rt: &mut SyscallContext, ptr: u32, values: &[u32]) -> Self {
+        Self { ptr, memory_records: rt.mw_slice(ptr, &values) }
+    }
+
+    pub fn prev_value_as_biguint(&self) -> BigUint {
+        BigUint::from_bytes_le(
+            &self
+                .memory_records
+                .iter()
+                .flat_map(|word| word.prev_value.to_le_bytes())
+                .collect::<Vec<u8>>(),
+        )
+    }
+}

crates/core/executor/src/events/precompiles/mod.rs

@@ -1,3 +1,4 @@
+mod bn254_scalar;
 mod ec;
 mod edwards;
 mod fptower;
@@ -6,6 +7,9 @@ mod sha256_compress;
 mod sha256_extend;
 mod uint256;
 
+pub use bn254_scalar::{
+    create_bn254_scalar_arith_event, Bn254FieldArithEvent, Bn254FieldOperation, NUM_WORDS_PER_FE,
+};
 pub use ec::*;
 pub use edwards::*;
 pub use fptower::*;

crates/core/executor/src/executor.rs

@@ -770,6 +770,10 @@ impl<'a> Executor<'a> {
                 let value = (memory_read_value).to_le_bytes()[(addr % 4) as usize];
                 a = ((value as i8) as i32) as u32;
                 memory_store_value = Some(memory_read_value);
+                //println!(
+                //    "[clk: {}, pc: 0x{:x}] LB: {:?} <- {:x}",
+                //    self.state.global_clk, self.state.pc, rd, a
+                //);
                 self.rw(rd, a);
             }
             Opcode::LH => {
@@ -784,6 +788,10 @@ impl<'a> Executor<'a> {
                 };
                 a = ((value as i16) as i32) as u32;
                 memory_store_value = Some(memory_read_value);
+                //println!(
+                //    "[clk: {}, pc: 0x{:x}] LH: {:?} <- {:x}",
+                //    self.state.global_clk, self.state.pc, rd, a
+                //);
                 self.rw(rd, a);
             }
             Opcode::LW => {
@@ -793,6 +801,10 @@ impl<'a> Executor<'a> {
                 }
                 a = memory_read_value;
                 memory_store_value = Some(memory_read_value);
+                //println!(
+                //    "[clk: {}, pc: 0x{:x}] LW: {:?} <- {}",
+                //    self.state.global_clk, self.state.pc, rd, a
+                //);
                 self.rw(rd, a);
             }
             Opcode::LBU => {
@@ -828,6 +840,10 @@ impl<'a> Executor<'a> {
                     _ => unreachable!(),
                 };
                 memory_store_value = Some(value);
+                //println!(
+                //    "[clk: {}, pc: 0x{:x}] SB 0x{:x} <- 0x{:x}",
+                //    self.state.global_clk, pc, addr, value
+                //);
                 self.mw_cpu(align(addr), value, MemoryAccessPosition::Memory);
             }
             Opcode::SH => {
@@ -841,6 +857,10 @@ impl<'a> Executor<'a> {
                     _ => unreachable!(),
                 };
                 memory_store_value = Some(value);
+                //println!(
+                //    "[clk: {}, pc: 0x{:x}] SH 0x{:x} <- 0x{:x}",
+                //    self.state.global_clk, pc, addr, value
+                //);
                 self.mw_cpu(align(addr), value, MemoryAccessPosition::Memory);
             }
             Opcode::SW => {
@@ -850,6 +870,10 @@ impl<'a> Executor<'a> {
                 }
                 let value = a;
                 memory_store_value = Some(value);
+                //println!(
+                //    "[clk: {}, pc: 0x{:x}] SW 0x{:x} <- 0x{:x}",
+                //    self.state.global_clk, pc, addr, value
+                //);
                 self.mw_cpu(align(addr), value, MemoryAccessPosition::Memory);
             }
 
@@ -941,9 +965,18 @@ impl<'a> Executor<'a> {
                     return Err(ExecutionError::InvalidSyscallUsage(syscall_id as u64));
                 }
 
+                let global_clk = self.state.global_clk;
                 let syscall_impl = self.get_syscall(syscall).cloned();
                 let mut precompile_rt = SyscallContext::new(self);
                 precompile_rt.syscall_lookup_id = syscall_lookup_id;
+                log::trace!(
+                    "[clk: {}, pc: 0x{:x}] ecall syscall_id=0x{:x}, b: 0x{:x}, c: 0x{:x}",
+                    global_clk,
+                    pc,
+                    syscall_id,
+                    b,
+                    c,
+                );
                 let (precompile_next_pc, precompile_cycles, returned_exit_code) =
                     if let Some(syscall_impl) = syscall_impl {
                         // Executing a syscall optionally returns a value to write to the t0
@@ -991,7 +1024,20 @@ impl<'a> Executor<'a> {
                     _ => (self.opts.split_opts.deferred, 1),
                 };
                 let nonce = (((*syscall_count as usize) % threshold) * multiplier) as u32;
-                self.record.nonce_lookup.insert(syscall_lookup_id, nonce);
+                // FIXME
+                match syscall {
+                    SyscallCode::BN254_SCALAR_MAC
+                    | SyscallCode::BN254_SCALAR_MUL
+                    | SyscallCode::MEMCPY_32
+                    | SyscallCode::MEMCPY_64 => {}
+                    _ => {
+                        self.record.nonce_lookup.insert(syscall_lookup_id, nonce);
+                    }
+                }
+
+                //log::info!(
+                //    "execute_instruction {syscall:?} {syscall_count} {nonce} {syscall_lookup_id}"
+                //);
                 *syscall_count += 1;
             }
             Opcode::EBREAK => {