sp1_core_machine/syscall/instructions/
trace.rs

1use std::{borrow::BorrowMut, mem::MaybeUninit};
2
3use hashbrown::HashMap;
4use itertools::Itertools;
5use rayon::iter::{ParallelBridge, ParallelIterator};
6use slop_air::BaseAir;
7use slop_algebra::PrimeField32;
8use sp1_core_executor::{
9    events::{ByteLookupEvent, ByteRecord, MemoryRecordEnum, SyscallEvent},
10    ExecutionRecord, Program, RTypeRecord, SyscallCode, HALT_PC,
11};
12use sp1_hypercube::{addr_to_limbs, air::MachineAir, Word};
13use sp1_primitives::consts::u64_to_u16_limbs;
14use struct_reflection::StructReflectionHelper;
15
16use crate::{
17    operations::SP1FieldWordRangeChecker, utils::next_multiple_of_32, TrustMode, UserMode,
18    UserModeSyscallInstrCols,
19};
20
21use super::{columns::SyscallInstrColumns, SyscallInstrsChip};
22
23impl<F: PrimeField32, M: TrustMode> MachineAir<F> for SyscallInstrsChip<M> {
24    type Record = ExecutionRecord;
25
26    type Program = Program;
27
28    fn name(&self) -> &'static str {
29        if M::IS_TRUSTED {
30            "SyscallInstrs"
31        } else {
32            "SyscallInstrsUser"
33        }
34    }
35
36    fn num_rows(&self, input: &Self::Record) -> Option<usize> {
37        if input.program.enable_untrusted_programs == M::IS_TRUSTED {
38            return Some(0);
39        }
40        let nb_rows = input.syscall_events.len();
41        let size_log2 = input.fixed_log2_rows::<F, _>(self);
42        let padded_nb_rows = next_multiple_of_32(nb_rows, size_log2);
43        Some(padded_nb_rows)
44    }
45
46    fn generate_trace_into(
47        &self,
48        input: &ExecutionRecord,
49        output: &mut ExecutionRecord,
50        buffer: &mut [MaybeUninit<F>],
51    ) {
52        if input.program.enable_untrusted_programs == M::IS_TRUSTED {
53            return;
54        }
55        let chunk_size = std::cmp::max((input.syscall_events.len()) / num_cpus::get(), 1);
56        let padded_nb_rows =
57            <SyscallInstrsChip<M> as MachineAir<F>>::num_rows(self, input).unwrap();
58        let num_event_rows = input.syscall_events.len();
59        let width = <SyscallInstrsChip<M> as BaseAir<F>>::width(self);
60
61        unsafe {
62            let padding_start = num_event_rows * width;
63            let padding_size = (padded_nb_rows - num_event_rows) * width;
64            if padding_size > 0 {
65                core::ptr::write_bytes(buffer[padding_start..].as_mut_ptr(), 0, padding_size);
66            }
67        }
68
69        let buffer_ptr = buffer.as_mut_ptr() as *mut F;
70        let values = unsafe { core::slice::from_raw_parts_mut(buffer_ptr, num_event_rows * width) };
71
72        let blu_events = values
73            .chunks_mut(chunk_size * width)
74            .enumerate()
75            .par_bridge()
76            .map(|(i, rows)| {
77                let mut blu: HashMap<ByteLookupEvent, usize> = HashMap::new();
78                rows.chunks_mut(width).enumerate().for_each(|(j, row)| {
79                    let idx = i * chunk_size + j;
80                    let cols: &mut SyscallInstrColumns<F, M> = row.borrow_mut();
81
82                    if idx < input.syscall_events.len() {
83                        let event = &input.syscall_events[idx];
84                        self.event_to_row(&event.0, &event.1, cols, &mut blu);
85                        cols.state.populate(&mut blu, event.0.clk, event.0.pc);
86                        cols.adapter.populate(&mut blu, event.1);
87                        if !M::IS_TRUSTED {
88                            let cols: &mut SyscallInstrColumns<F, UserMode> = row.borrow_mut();
89                            cols.user_mode_cols = UserModeSyscallInstrCols::<F>::default();
90                            let syscall_id = event.0.syscall_id;
91                            cols.user_mode_cols.is_sig_return.populate_from_field_element(
92                                F::from_canonical_u32(syscall_id)
93                                    - F::from_canonical_u32(SyscallCode::SIG_RETURN.syscall_id()),
94                            );
95                            // Populate `is_page_protect`.
96                            cols.user_mode_cols.is_page_protect.populate_from_field_element(
97                                F::from_canonical_u32(syscall_id)
98                                    - F::from_canonical_u32(SyscallCode::MPROTECT.syscall_id()),
99                            );
100                            #[cfg(feature = "mprotect")]
101                            for i in 0..3 {
102                                cols.user_mode_cols.addresses[i] =
103                                    addr_to_limbs(input.public_values.trap_context[i]);
104                            }
105                            if let Some(pc_record) = event.0.sig_return_pc_record {
106                                cols.user_mode_cols
107                                    .next_pc_record
108                                    .populate(MemoryRecordEnum::Read(pc_record), &mut blu);
109                                let next_pc = pc_record.value;
110                                cols.next_pc = addr_to_limbs::<F>(next_pc);
111                            }
112                            if let Some(trap_result) = event.0.trap_result {
113                                cols.user_mode_cols.trap_operation.populate(&mut blu, trap_result);
114                                let trap_code = trap_result.code_record.value;
115                                cols.user_mode_cols.is_not_trap.populate(trap_code);
116                                cols.user_mode_cols.trap_code = F::from_canonical_u64(trap_code);
117                                let next_pc = trap_result.handler_record.value;
118                                cols.next_pc = addr_to_limbs::<F>(next_pc);
119                            } else {
120                                cols.user_mode_cols.is_not_trap.populate(0);
121                            }
122                        }
123                    }
124                });
125                blu
126            })
127            .collect::<Vec<_>>();
128
129        output.add_byte_lookup_events_from_maps(blu_events.iter().collect_vec());
130    }
131
132    fn included(&self, shard: &Self::Record) -> bool {
133        if let Some(shape) = shard.shape.as_ref() {
134            shape.included::<F, _>(self)
135        } else {
136            !shard.syscall_events.is_empty()
137                && (M::IS_TRUSTED != shard.program.enable_untrusted_programs)
138        }
139    }
140
141    fn column_names(&self) -> Vec<String> {
142        SyscallInstrColumns::<F, M>::struct_reflection().unwrap()
143    }
144}
145
146impl<M: TrustMode> SyscallInstrsChip<M> {
147    fn event_to_row<F: PrimeField32>(
148        &self,
149        event: &SyscallEvent,
150        record: &RTypeRecord,
151        cols: &mut SyscallInstrColumns<F, M>,
152        blu: &mut impl ByteRecord,
153    ) {
154        cols.is_real = F::one();
155
156        cols.op_a_value = Word::from(record.a.value());
157        cols.a_low_bytes.populate_u16_to_u8_safe(blu, record.a.prev_value());
158        blu.add_u16_range_checks(&u64_to_u16_limbs(record.a.value()));
159        let a_prev_value = record.a.prev_value().to_le_bytes().map(F::from_canonical_u8);
160
161        let syscall_id = a_prev_value[0];
162
163        cols.is_halt =
164            F::from_bool(syscall_id == F::from_canonical_u32(SyscallCode::HALT.syscall_id()));
165
166        if cols.is_halt == F::one() {
167            cols.next_pc = [F::from_canonical_u64(HALT_PC), F::zero(), F::zero()];
168        } else {
169            cols.next_pc = [
170                F::from_canonical_u32(((event.pc & 0xFFFF) as u32) + 4),
171                F::from_canonical_u32(((event.pc >> 16) & 0xFFFF) as u32),
172                F::from_canonical_u32(((event.pc >> 32) & 0xFFFF) as u32),
173            ];
174        }
175
176        // Populate `is_enter_unconstrained`.
177        cols.is_enter_unconstrained.populate_from_field_element(
178            syscall_id - F::from_canonical_u32(SyscallCode::ENTER_UNCONSTRAINED.syscall_id()),
179        );
180
181        // Populate `is_hint_len`.
182        cols.is_hint_len.populate_from_field_element(
183            syscall_id - F::from_canonical_u32(SyscallCode::HINT_LEN.syscall_id()),
184        );
185
186        // Populate `is_halt`.
187        cols.is_halt_check.populate_from_field_element(
188            syscall_id - F::from_canonical_u32(SyscallCode::HALT.syscall_id()),
189        );
190
191        // Populate `is_commit`.
192        cols.is_commit.populate_from_field_element(
193            syscall_id - F::from_canonical_u32(SyscallCode::COMMIT.syscall_id()),
194        );
195
196        // Populate `is_commit_deferred_proofs`.
197        cols.is_commit_deferred_proofs.populate_from_field_element(
198            syscall_id - F::from_canonical_u32(SyscallCode::COMMIT_DEFERRED_PROOFS.syscall_id()),
199        );
200
201        cols.index_bitmap = [F::zero(); 8];
202        cols.expected_public_values_digest = [F::zero(); 4];
203
204        // For `COMMIT` or `COMMIT_DEFERRED_PROOFS`, set the index bitmap and digest word.
205        if syscall_id == F::from_canonical_u32(SyscallCode::COMMIT.syscall_id())
206            || syscall_id == F::from_canonical_u32(SyscallCode::COMMIT_DEFERRED_PROOFS.syscall_id())
207        {
208            let digest_idx = record.b.value() as usize;
209            cols.index_bitmap[digest_idx] = F::one();
210        }
211
212        // If the syscall is `COMMIT`, set the expected public values digest and range check.
213        if syscall_id == F::from_canonical_u32(SyscallCode::COMMIT.syscall_id()) {
214            let digest_bytes = (record.c.value() as u32).to_le_bytes();
215            cols.expected_public_values_digest = digest_bytes.map(F::from_canonical_u8);
216            blu.add_u8_range_checks(&digest_bytes);
217        }
218
219        // Add the SP1Field range check of the operands.
220        if cols.is_halt == F::one() {
221            cols.op_b_range_check.populate(Word::from(event.arg1), blu);
222        } else {
223            cols.op_b_range_check = SP1FieldWordRangeChecker::default();
224        }
225
226        if syscall_id == F::from_canonical_u32(SyscallCode::COMMIT_DEFERRED_PROOFS.syscall_id()) {
227            cols.op_c_range_check.populate(Word::from(event.arg2), blu);
228        } else {
229            cols.op_c_range_check = SP1FieldWordRangeChecker::default();
230        }
231    }
232}
sp1_core_machine/syscall/instructions/trace.rs

sp1_core_machine/syscall/instructions/
trace.rs
