impl io and crypto ops

Author: plafer

processor/src/parallel/basic_block.rs

@@ -4,8 +4,8 @@ use miden_air::trace::{
     DECODER_TRACE_OFFSET,
     decoder::{
         ADDR_COL_IDX, GROUP_COUNT_COL_IDX, HASHER_STATE_OFFSET, IN_SPAN_COL_IDX,
-        NUM_OP_BATCH_FLAGS, NUM_OP_BITS, NUM_OP_BITS_EXTRA_COLS, OP_BATCH_FLAGS_OFFSET,
-        OP_BITS_EXTRA_COLS_OFFSET, OP_BITS_OFFSET, OP_INDEX_COL_IDX,
+        NUM_OP_BATCH_FLAGS, NUM_OP_BITS, NUM_OP_BITS_EXTRA_COLS, NUM_USER_OP_HELPERS,
+        OP_BATCH_FLAGS_OFFSET, OP_BITS_EXTRA_COLS_OFFSET, OP_BITS_OFFSET, OP_INDEX_COL_IDX,
     },
 };
 use vm_core::{
@@ -194,6 +194,7 @@ impl CoreTraceFragmentGenerator {
         &mut self,
         operation: Operation,
         op_idx_in_group: usize,
+        user_op_helpers: Option<[Felt; NUM_USER_OP_HELPERS]>,
     ) -> ControlFlow<()> {
         let row_idx = self.num_rows_built();
 
@@ -208,7 +209,7 @@ impl CoreTraceFragmentGenerator {
 
         self.fragment.columns[DECODER_TRACE_OFFSET + ADDR_COL_IDX][row_idx] = block.addr;
 
-        // TODO(plafer): copy/pasted from trace_builder.rs; put in some `append_opcode` method
+        // TODO(plafer): copy/pasted from trace_builder.rs; use `append_opcode` method
         {
             let opcode = operation.op_code();
             for i in 0..NUM_OP_BITS {
@@ -217,17 +218,28 @@ impl CoreTraceFragmentGenerator {
             }
         }
 
-        // hasher trace
+        // hasher trace: group_ops_left and parent address
         self.fragment.columns[DECODER_TRACE_OFFSET + HASHER_STATE_OFFSET][row_idx] =
             ctx.group_ops_left;
         self.fragment.columns[DECODER_TRACE_OFFSET + HASHER_STATE_OFFSET + 1][row_idx] =
             block.parent_addr;
-        self.fragment.columns[DECODER_TRACE_OFFSET + HASHER_STATE_OFFSET + 2][row_idx] = ZERO;
-        self.fragment.columns[DECODER_TRACE_OFFSET + HASHER_STATE_OFFSET + 3][row_idx] = ZERO;
-        self.fragment.columns[DECODER_TRACE_OFFSET + HASHER_STATE_OFFSET + 4][row_idx] = ZERO;
-        self.fragment.columns[DECODER_TRACE_OFFSET + HASHER_STATE_OFFSET + 5][row_idx] = ZERO;
-        self.fragment.columns[DECODER_TRACE_OFFSET + HASHER_STATE_OFFSET + 6][row_idx] = ZERO;
-        self.fragment.columns[DECODER_TRACE_OFFSET + HASHER_STATE_OFFSET + 7][row_idx] = ZERO;
+
+        // hasher trace: user op helpers
+        {
+            let user_op_helpers = user_op_helpers.unwrap_or([ZERO; NUM_USER_OP_HELPERS]);
+            self.fragment.columns[DECODER_TRACE_OFFSET + HASHER_STATE_OFFSET + 2][row_idx] =
+                user_op_helpers[0];
+            self.fragment.columns[DECODER_TRACE_OFFSET + HASHER_STATE_OFFSET + 3][row_idx] =
+                user_op_helpers[1];
+            self.fragment.columns[DECODER_TRACE_OFFSET + HASHER_STATE_OFFSET + 4][row_idx] =
+                user_op_helpers[2];
+            self.fragment.columns[DECODER_TRACE_OFFSET + HASHER_STATE_OFFSET + 5][row_idx] =
+                user_op_helpers[3];
+            self.fragment.columns[DECODER_TRACE_OFFSET + HASHER_STATE_OFFSET + 6][row_idx] =
+                user_op_helpers[4];
+            self.fragment.columns[DECODER_TRACE_OFFSET + HASHER_STATE_OFFSET + 7][row_idx] =
+                user_op_helpers[5];
+        }
 
         self.fragment.columns[DECODER_TRACE_OFFSET + IN_SPAN_COL_IDX][row_idx] = ONE;
         self.fragment.columns[DECODER_TRACE_OFFSET + GROUP_COUNT_COL_IDX][row_idx] =

processor/src/parallel/mod.rs

@@ -3,7 +3,10 @@ use core::ops::ControlFlow;
 
 use miden_air::{
     RowIndex,
-    trace::{DECODER_TRACE_WIDTH, STACK_TRACE_WIDTH, SYS_TRACE_WIDTH, decoder::NUM_OP_BITS},
+    trace::{
+        DECODER_TRACE_WIDTH, STACK_TRACE_WIDTH, SYS_TRACE_WIDTH,
+        decoder::{NUM_OP_BITS, NUM_USER_OP_HELPERS},
+    },
 };
 use tokio::{sync::mpsc::Receiver, task::JoinHandle};
 use traversal::ExecutionTraversal;
@@ -717,16 +720,18 @@ impl CoreTraceFragmentGenerator {
     /// any memory or advice provider operations for parallel trace generation.
     fn execute_op(&mut self, op: Operation, op_idx_in_group: usize) -> ControlFlow<()> {
         // Execute the operation by dispatching to appropriate operation methods
-        self.dispatch_operation(&op);
+        let user_op_helpers = self.dispatch_operation(&op);
 
         // write the operation to the trace
-        self.add_operation_trace_row(op, op_idx_in_group)
+        self.add_operation_trace_row(op, op_idx_in_group, user_op_helpers)
     }
 
     /// Dispatches the operation to the appropriate execution method.
-    fn dispatch_operation(&mut self, op: &Operation) {
+    fn dispatch_operation(&mut self, op: &Operation) -> Option<[Felt; NUM_USER_OP_HELPERS]> {
         use vm_core::Operation;
 
+        let mut user_op_helpers = None;
+
         match op {
             // ----- system operations ------------------------------------------------------------
             Operation::Noop => {
@@ -827,24 +832,32 @@ impl CoreTraceFragmentGenerator {
 
             // ----- input / output ---------------------------------------------------------------
             Operation::Push(value) => self.op_push(*value),
-            Operation::AdvPop => self.advpop(),
-            Operation::AdvPopW => self.advpopw(),
-            Operation::MLoadW => self.mloadw(),
-            Operation::MStoreW => self.mstorew(),
-            Operation::MLoad => self.mload(),
-            Operation::MStore => self.mstore(),
-            Operation::MStream => self.mstream(),
-            Operation::Pipe => self.pipe(),
+            Operation::AdvPop => self.op_advpop(),
+            Operation::AdvPopW => self.op_advpopw(),
+            Operation::MLoadW => self.op_mloadw(),
+            Operation::MStoreW => self.op_mstorew(),
+            Operation::MLoad => self.op_mload(),
+            Operation::MStore => self.op_mstore(),
+            Operation::MStream => self.op_mstream(),
+            Operation::Pipe => self.op_pipe(),
 
             // ----- cryptographic operations -----------------------------------------------------
-            Operation::HPerm => self.hperm(),
-            Operation::MpVerify(_err_code) => self.mpverify(),
-            Operation::MrUpdate => self.mrupdate(),
-            Operation::FriE2F4 => self.fri_ext2fold4(),
-            Operation::HornerBase => self.horner_eval_base(),
-            Operation::HornerExt => self.horner_eval_ext(),
-            Operation::ArithmeticCircuitEval => self.arithmetic_circuit_eval(),
+            Operation::HPerm => {
+                let hperm_helpers = self.op_hperm();
+                user_op_helpers = Some(hperm_helpers);
+            },
+            Operation::MpVerify(_err_code) => {
+                let mpverify_helpers = self.op_mpverify();
+                user_op_helpers = Some(mpverify_helpers);
+            },
+            Operation::MrUpdate => self.op_mrupdate(),
+            Operation::FriE2F4 => self.op_fri_ext2fold4(),
+            Operation::HornerBase => self.op_horner_eval_base(),
+            Operation::HornerExt => self.op_horner_eval_ext(),
+            Operation::ArithmeticCircuitEval => self.op_arithmetic_circuit_eval(),
         }
+
+        user_op_helpers
     }
 
     fn finalize_fragment(mut self) -> CoreTraceFragment {

processor/src/parallel/operations/crypto_ops.rs

@@ -1,136 +1,62 @@
-use vm_core::{ZERO, chiplets::hasher::apply_permutation};
+use miden_air::trace::decoder::NUM_USER_OP_HELPERS;
+use vm_core::{Felt, ZERO};
 
 use super::CoreTraceFragmentGenerator;
+use crate::processor::Processor;
 
 impl CoreTraceFragmentGenerator {
     /// Performs a hash permutation operation.
     /// Applies Rescue Prime Optimized permutation to the top 12 elements of the stack.
-    pub(crate) fn hperm(&mut self) {
-        // Get the top 12 elements from the stack (in reverse order for hasher state)
-        let mut hasher_state = [
-            self.stack_get(11),
-            self.stack_get(10),
-            self.stack_get(9),
-            self.stack_get(8),
-            self.stack_get(7),
-            self.stack_get(6),
-            self.stack_get(5),
-            self.stack_get(4),
-            self.stack_get(3),
-            self.stack_get(2),
-            self.stack_get(1),
-            self.stack_get(0),
-        ];
-
-        // TODO(plafer): use hasher state replay (and in other crypto ops)
-        // Apply the RPO permutation
-        apply_permutation(&mut hasher_state);
+    pub(crate) fn op_hperm(&mut self) -> [Felt; NUM_USER_OP_HELPERS] {
+        let (addr, computed_hash) = self.state.hasher.replay_permutation();
 
         // Put the result back on the stack (in reverse order)
-        for (i, &value) in hasher_state.iter().rev().enumerate() {
-            self.stack_set(i, value);
+        for (i, &value) in computed_hash.iter().rev().enumerate() {
+            self.stack_write(i, value);
         }
+
+        [addr, ZERO, ZERO, ZERO, ZERO, ZERO]
     }
 
     /// Verifies a Merkle path.
-    pub(crate) fn mpverify(&mut self) {
-        // For parallel trace generation, we assume the Merkle path verification is already done
-        // This would involve complex cryptographic verification in the actual implementation
-
-        // The operation pops the node value (4 elements), depth, index, and root (4 elements)
-        // and verifies the path. In parallel mode, we assume verification succeeds.
+    ///
+    /// In this implementation, we don't actually verify the path.
+    pub(crate) fn op_mpverify(&mut self) -> [Felt; NUM_USER_OP_HELPERS] {
+        let depth = self.stack_get(4);
+        let index = self.stack_get(5);
+        let root = self.stack_get_word(6);
 
-        // Stack layout: [node_value(4), depth, index, root(4), ...]
-        // After verification: [root(4), ...]
+        // Replay the Merkle path retrieval from the advice provider
+        let _path = self.state.advice.replay_merkle_path(root, depth, index);
+        let (addr, computed_root) = self.state.hasher.replay_build_merkle_root();
 
-        // Move root to top and remove other elements
-        let root = [
-            self.stack_get(9), // root[0]
-            self.stack_get(8), // root[1]
-            self.stack_get(7), // root[2]
-            self.stack_get(6), // root[3]
-        ];
-
-        // Set root at top of stack
-        for (i, &value) in root.iter().enumerate() {
-            self.stack_set(i, value);
-        }
+        debug_assert_eq!(root, computed_root, "Merkle root mismatch");
 
-        // Remove the consumed elements (node_value + depth + index = 6 elements)
-        self.stack_shift_left(6);
+        [addr, ZERO, ZERO, ZERO, ZERO, ZERO]
     }
 
     /// Updates the Merkle root.
-    pub(crate) fn mrupdate(&mut self) {
-        // For parallel trace generation, we assume the Merkle root update is already computed
-        // This would involve complex cryptographic computations in the actual implementation
-
-        // In a real implementation, this would:
-        // 1. Pop the old leaf value, new leaf value, and Merkle path
-        // 2. Compute the new root by updating the path with the new leaf
-        // 3. Push the new root onto the stack
-
-        // For now, we'll assume the operation succeeds and produces a placeholder root
-        let new_root = [ZERO; 4]; // Placeholder for computed new root
-
-        // Remove consumed elements and place new root
-        // This is a simplified implementation - actual stack manipulation would depend
-        // on the specific input format
-        for (i, &value) in new_root.iter().enumerate() {
-            self.stack_set(i, value);
-        }
+    pub(crate) fn op_mrupdate(&mut self) {
+        todo!()
     }
 
     /// Performs FRI extension fold operation.
-    pub(crate) fn fri_ext2fold4(&mut self) {
-        // For parallel trace generation, we assume the FRI fold operation is already computed
-        // This is a complex cryptographic operation used in polynomial commitments
-
-        // In actual implementation, this would perform FRI (Fast Reed-Solomon Interactive Oracle
-        // Proofs) extension field folding operations
-
-        // For now, we'll assume the operation succeeds with a placeholder result
+    pub(crate) fn op_fri_ext2fold4(&mut self) {
+        todo!()
     }
 
     /// Evaluates a polynomial using Horner's method (base field).
-    pub(crate) fn horner_eval_base(&mut self) {
-        // For parallel trace generation, we assume the polynomial evaluation is already computed
-        // This would evaluate a polynomial at a given point using Horner's method in the base field
-
-        // In actual implementation, this would:
-        // 1. Pop polynomial coefficients and evaluation point from stack
-        // 2. Compute polynomial value using Horner's method: p(x) = a_n + x(a_{n-1} + x(a_{n-2} +
-        //    ...))
-        // 3. Push result onto stack
-
-        let result = ZERO; // Placeholder for computed result
-        self.stack_set(0, result);
+    pub(crate) fn op_horner_eval_base(&mut self) {
+        todo!()
     }
 
     /// Evaluates a polynomial using Horner's method (extension field).
-    pub(crate) fn horner_eval_ext(&mut self) {
-        // For parallel trace generation, we assume the polynomial evaluation is already computed
-        // This would evaluate a polynomial at a given point using Horner's method in the extension
-        // field
-
-        // Similar to base field version but operates in quadratic extension field
-        let result = [ZERO, ZERO]; // Placeholder for extension field result
-
-        self.stack_set(0, result[0]);
-        self.stack_set(1, result[1]);
+    pub(crate) fn op_horner_eval_ext(&mut self) {
+        todo!()
     }
 
     /// Evaluates an arithmetic circuit.
-    pub(crate) fn arithmetic_circuit_eval(&mut self) {
-        // For parallel trace generation, we assume the circuit evaluation is already computed
-        // This would evaluate an arithmetic circuit with given inputs
-
-        // In actual implementation, this would:
-        // 1. Pop circuit description and inputs from stack
-        // 2. Evaluate the arithmetic circuit
-        // 3. Push results onto stack
-
-        let result = ZERO; // Placeholder for computed result
-        self.stack_set(0, result);
+    pub(crate) fn op_arithmetic_circuit_eval(&mut self) {
+        todo!()
     }
 }