openvm_rv32im_circuit/hintstore/
execution.rs

1use std::{
2    borrow::{Borrow, BorrowMut},
3    mem::size_of,
4};
5
6use openvm_circuit::{arch::*, system::memory::online::GuestMemory};
7use openvm_circuit_primitives_derive::AlignedBytesBorrow;
8use openvm_instructions::{
9    instruction::Instruction,
10    program::DEFAULT_PC_STEP,
11    riscv::{RV32_MEMORY_AS, RV32_REGISTER_AS, RV32_REGISTER_NUM_LIMBS},
12    LocalOpcode,
13};
14use openvm_rv32im_transpiler::{
15    Rv32HintStoreOpcode,
16    Rv32HintStoreOpcode::{HINT_BUFFER, HINT_STOREW},
17};
18use openvm_stark_backend::p3_field::PrimeField32;
19
20use super::Rv32HintStoreExecutor;
21
22#[derive(AlignedBytesBorrow, Clone)]
23#[repr(C)]
24struct HintStorePreCompute {
25    c: u32,
26    a: u8,
27    b: u8,
28}
29
30impl Rv32HintStoreExecutor {
31    #[inline(always)]
32    fn pre_compute_impl<F: PrimeField32>(
33        &self,
34        pc: u32,
35        inst: &Instruction<F>,
36        data: &mut HintStorePreCompute,
37    ) -> Result<Rv32HintStoreOpcode, StaticProgramError> {
38        let &Instruction {
39            opcode,
40            a,
41            b,
42            c,
43            d,
44            e,
45            ..
46        } = inst;
47        if d.as_canonical_u32() != RV32_REGISTER_AS || e.as_canonical_u32() != RV32_MEMORY_AS {
48            return Err(StaticProgramError::InvalidInstruction(pc));
49        }
50        *data = {
51            HintStorePreCompute {
52                c: c.as_canonical_u32(),
53                a: a.as_canonical_u32() as u8,
54                b: b.as_canonical_u32() as u8,
55            }
56        };
57        Ok(Rv32HintStoreOpcode::from_usize(
58            opcode.local_opcode_idx(self.offset),
59        ))
60    }
61}
62
63macro_rules! dispatch {
64    ($execute_impl:ident, $local_opcode:ident) => {
65        match $local_opcode {
66            HINT_STOREW => Ok($execute_impl::<_, _, true>),
67            HINT_BUFFER => Ok($execute_impl::<_, _, false>),
68        }
69    };
70}
71
72impl<F> InterpreterExecutor<F> for Rv32HintStoreExecutor
73where
74    F: PrimeField32,
75{
76    #[inline(always)]
77    fn pre_compute_size(&self) -> usize {
78        size_of::<HintStorePreCompute>()
79    }
80
81    #[cfg(not(feature = "tco"))]
82    fn pre_compute<Ctx: ExecutionCtxTrait>(
83        &self,
84        pc: u32,
85        inst: &Instruction<F>,
86        data: &mut [u8],
87    ) -> Result<ExecuteFunc<F, Ctx>, StaticProgramError> {
88        let pre_compute: &mut HintStorePreCompute = data.borrow_mut();
89        let local_opcode = self.pre_compute_impl(pc, inst, pre_compute)?;
90        dispatch!(execute_e1_handler, local_opcode)
91    }
92
93    #[cfg(feature = "tco")]
94    fn handler<Ctx>(
95        &self,
96        pc: u32,
97        inst: &Instruction<F>,
98        data: &mut [u8],
99    ) -> Result<Handler<F, Ctx>, StaticProgramError>
100    where
101        Ctx: ExecutionCtxTrait,
102    {
103        let pre_compute: &mut HintStorePreCompute = data.borrow_mut();
104        let local_opcode = self.pre_compute_impl(pc, inst, pre_compute)?;
105        dispatch!(execute_e1_handler, local_opcode)
106    }
107}
108
109#[cfg(feature = "aot")]
110impl<F> AotExecutor<F> for Rv32HintStoreExecutor where F: PrimeField32 {}
111
112impl<F> InterpreterMeteredExecutor<F> for Rv32HintStoreExecutor
113where
114    F: PrimeField32,
115{
116    fn metered_pre_compute_size(&self) -> usize {
117        size_of::<E2PreCompute<HintStorePreCompute>>()
118    }
119
120    #[cfg(not(feature = "tco"))]
121    fn metered_pre_compute<Ctx>(
122        &self,
123        chip_idx: usize,
124        pc: u32,
125        inst: &Instruction<F>,
126        data: &mut [u8],
127    ) -> Result<ExecuteFunc<F, Ctx>, StaticProgramError>
128    where
129        Ctx: MeteredExecutionCtxTrait,
130    {
131        let pre_compute: &mut E2PreCompute<HintStorePreCompute> = data.borrow_mut();
132        pre_compute.chip_idx = chip_idx as u32;
133        let local_opcode = self.pre_compute_impl(pc, inst, &mut pre_compute.data)?;
134        dispatch!(execute_e2_handler, local_opcode)
135    }
136
137    #[cfg(feature = "tco")]
138    fn metered_handler<Ctx>(
139        &self,
140        chip_idx: usize,
141        pc: u32,
142        inst: &Instruction<F>,
143        data: &mut [u8],
144    ) -> Result<Handler<F, Ctx>, StaticProgramError>
145    where
146        Ctx: MeteredExecutionCtxTrait,
147    {
148        let pre_compute: &mut E2PreCompute<HintStorePreCompute> = data.borrow_mut();
149        pre_compute.chip_idx = chip_idx as u32;
150        let local_opcode = self.pre_compute_impl(pc, inst, &mut pre_compute.data)?;
151        dispatch!(execute_e2_handler, local_opcode)
152    }
153}
154
155#[cfg(feature = "aot")]
156impl<F> AotMeteredExecutor<F> for Rv32HintStoreExecutor where F: PrimeField32 {}
157/// Return the number of used rows.
158#[inline(always)]
159unsafe fn execute_e12_impl<F: PrimeField32, CTX: ExecutionCtxTrait, const IS_HINT_STOREW: bool>(
160    pre_compute: &HintStorePreCompute,
161    exec_state: &mut VmExecState<F, GuestMemory, CTX>,
162) -> Result<u32, ExecutionError> {
163    let pc = exec_state.pc();
164    let mem_ptr_limbs = exec_state.vm_read::<u8, 4>(RV32_REGISTER_AS, pre_compute.b as u32);
165    let mem_ptr = u32::from_le_bytes(mem_ptr_limbs);
166
167    let num_words = if IS_HINT_STOREW {
168        1
169    } else {
170        let num_words_limbs = exec_state.vm_read::<u8, 4>(RV32_REGISTER_AS, pre_compute.a as u32);
171        u32::from_le_bytes(num_words_limbs)
172    };
173    debug_assert_ne!(num_words, 0);
174
175    if exec_state.streams.hint_stream.len() < RV32_REGISTER_NUM_LIMBS * num_words as usize {
176        let err = ExecutionError::HintOutOfBounds { pc };
177        return Err(err);
178    }
179
180    for word_index in 0..num_words {
181        let data: [u8; RV32_REGISTER_NUM_LIMBS] = std::array::from_fn(|_| {
182            exec_state
183                .streams
184                .hint_stream
185                .pop_front()
186                .unwrap()
187                .as_canonical_u32() as u8
188        });
189        exec_state.vm_write(
190            RV32_MEMORY_AS,
191            mem_ptr + (RV32_REGISTER_NUM_LIMBS as u32 * word_index),
192            &data,
193        );
194    }
195
196    exec_state.set_pc(pc.wrapping_add(DEFAULT_PC_STEP));
197    Ok(num_words)
198}
199
200#[create_handler]
201#[inline(always)]
202unsafe fn execute_e1_impl<F: PrimeField32, CTX: ExecutionCtxTrait, const IS_HINT_STOREW: bool>(
203    pre_compute: *const u8,
204    exec_state: &mut VmExecState<F, GuestMemory, CTX>,
205) -> Result<(), ExecutionError> {
206    let pre_compute: &HintStorePreCompute =
207        std::slice::from_raw_parts(pre_compute, size_of::<HintStorePreCompute>()).borrow();
208    execute_e12_impl::<F, CTX, IS_HINT_STOREW>(pre_compute, exec_state)?;
209    Ok(())
210}
211
212#[create_handler]
213#[inline(always)]
214unsafe fn execute_e2_impl<
215    F: PrimeField32,
216    CTX: MeteredExecutionCtxTrait,
217    const IS_HINT_STOREW: bool,
218>(
219    pre_compute: *const u8,
220    exec_state: &mut VmExecState<F, GuestMemory, CTX>,
221) -> Result<(), ExecutionError> {
222    let pre_compute: &E2PreCompute<HintStorePreCompute> =
223        std::slice::from_raw_parts(pre_compute, size_of::<E2PreCompute<HintStorePreCompute>>())
224            .borrow();
225    let height_delta = execute_e12_impl::<F, CTX, IS_HINT_STOREW>(&pre_compute.data, exec_state)?;
226    exec_state
227        .ctx
228        .on_height_change(pre_compute.chip_idx as usize, height_delta);
229    Ok(())
230}
openvm_rv32im_circuit/hintstore/execution.rs

openvm_rv32im_circuit/hintstore/
execution.rs
