WIP parallel processor

Author: plafer

Cargo.lock

@@ -31,6 +31,7 @@ miette = { package = "miden-miette", version = "8.0", default-features = false,
     "fancy-no-syscall",
     "derive"
 ] }
+tokio = { version = "1.45", default-features = false, features = ["rt", "sync"] }
 tracing = { version = "0.1", default-features = false, features = ["attributes"] }
 vm-core = { package = "miden-core", path = "../core", version = "0.15", default-features = false, features = ["diagnostics"] }
 winter-prover = { package = "winter-prover", version = "0.12", default-features = false }

processor/Cargo.toml

@@ -37,6 +37,7 @@ use vm_core::{
 pub use winter_prover::matrix::ColMatrix;
 
 pub mod fast;
+pub mod parallel;
 
 mod operations;
 

processor/src/lib.rs

@@ -0,0 +1,63 @@
+use core::ops::ControlFlow;
+
+use vm_core::{Word, mast::CallNode};
+
+use super::{MainTraceFragmentGenerator, TraceRowType, trace_builder::OperationTraceConfig};
+
+impl MainTraceFragmentGenerator {
+    /// Adds a trace row for a CALL/SYSCALL operation (start or end) to the main trace fragment.
+    ///
+    /// This method populates the system, decoder, and stack columns for a single trace row
+    /// corresponding to either the start or end of a CALL/SYSCALL block execution. It uses the
+    /// shared control flow trace building infrastructure.
+    pub fn add_call_trace_row(
+        &mut self,
+        call_node: &CallNode,
+        program: &vm_core::mast::MastForest,
+        trace_type: TraceRowType,
+    ) -> ControlFlow<()> {
+        // For CALL/SYSCALL operations, the hasher state in start operations contains the callee
+        // hash in the first half, and zeros in the second half (since CALL only has one
+        // child)
+        let callee_hash: Word = program
+            .get_node_by_id(call_node.callee())
+            .expect("callee should exist")
+            .digest()
+            .into();
+        let zero_hash: Word = [vm_core::ZERO; 4];
+
+        let config = OperationTraceConfig {
+            start_opcode: if call_node.is_syscall() {
+                vm_core::Operation::SysCall.op_code()
+            } else {
+                vm_core::Operation::Call.op_code()
+            },
+            start_hasher_state: (callee_hash, zero_hash),
+            end_node_digest: call_node.digest().into(),
+        };
+
+        self.add_control_flow_trace_row(config, trace_type)
+    }
+
+    /// Adds a trace row for the start of a CALL/SYSCALL operation.
+    ///
+    /// This is a convenience method that calls `add_call_trace_row` with `TraceRowType::Start`.
+    pub fn add_call_start_trace_row(
+        &mut self,
+        call_node: &CallNode,
+        program: &vm_core::mast::MastForest,
+    ) -> ControlFlow<()> {
+        self.add_call_trace_row(call_node, program, TraceRowType::Start)
+    }
+
+    /// Adds a trace row for the end of a CALL/SYSCALL operation.
+    ///
+    /// This is a convenience method that calls `add_call_trace_row` with `TraceRowType::End`.
+    pub fn add_call_end_trace_row(
+        &mut self,
+        call_node: &CallNode,
+        program: &vm_core::mast::MastForest,
+    ) -> ControlFlow<()> {
+        self.add_call_trace_row(call_node, program, TraceRowType::End)
+    }
+}

processor/src/parallel/call.rs

@@ -0,0 +1,48 @@
+use core::ops::ControlFlow;
+
+use vm_core::{Word, mast::DynNode};
+
+use super::{MainTraceFragmentGenerator, TraceRowType, trace_builder::OperationTraceConfig};
+
+impl MainTraceFragmentGenerator {
+    /// Adds a trace row for a DYN/DYNCALL operation (start or end) to the main trace fragment.
+    ///
+    /// This method populates the system, decoder, and stack columns for a single trace row
+    /// corresponding to either the start or end of a DYN/DYNCALL block execution. It uses the
+    /// shared control flow trace building infrastructure.
+    pub fn add_dyn_trace_row(
+        &mut self,
+        dyn_node: &DynNode,
+        trace_type: TraceRowType,
+    ) -> ControlFlow<()> {
+        // For DYN/DYNCALL operations, the hasher state is set to zeros since the dynamic target
+        // is resolved at runtime and cannot be known at compile time during parallel execution
+        let zero_hash: Word = [vm_core::ZERO; 4];
+
+        let config = OperationTraceConfig {
+            start_opcode: if dyn_node.is_dyncall() {
+                vm_core::Operation::Dyncall.op_code()
+            } else {
+                vm_core::Operation::Dyn.op_code()
+            },
+            start_hasher_state: (zero_hash, zero_hash),
+            end_node_digest: dyn_node.digest().into(),
+        };
+
+        self.add_control_flow_trace_row(config, trace_type)
+    }
+
+    /// Adds a trace row for the start of a DYN/DYNCALL operation.
+    ///
+    /// This is a convenience method that calls `add_dyn_trace_row` with `TraceRowType::Start`.
+    pub fn add_dyn_start_trace_row(&mut self, dyn_node: &DynNode) -> ControlFlow<()> {
+        self.add_dyn_trace_row(dyn_node, TraceRowType::Start)
+    }
+
+    /// Adds a trace row for the end of a DYN/DYNCALL operation.
+    ///
+    /// This is a convenience method that calls `add_dyn_trace_row` with `TraceRowType::End`.
+    pub fn add_dyn_end_trace_row(&mut self, dyn_node: &DynNode) -> ControlFlow<()> {
+        self.add_dyn_trace_row(dyn_node, TraceRowType::End)
+    }
+}

processor/src/parallel/dyn.rs

@@ -0,0 +1,61 @@
+use core::ops::ControlFlow;
+
+use vm_core::{Word, mast::JoinNode};
+
+use super::{MainTraceFragmentGenerator, TraceRowType, trace_builder::OperationTraceConfig};
+
+impl MainTraceFragmentGenerator {
+    /// Adds a trace row for a JOIN operation (start or end) to the main trace fragment.
+    ///
+    /// This method populates the system, decoder, and stack columns for a single trace row
+    /// corresponding to either the start or end of a JOIN block execution. It uses the
+    /// shared control flow trace building infrastructure.
+    pub fn add_join_trace_row(
+        &mut self,
+        join_node: &JoinNode,
+        program: &vm_core::mast::MastForest,
+        trace_type: TraceRowType,
+    ) -> ControlFlow<()> {
+        // Get the child hashes for the hasher state
+        let child1_hash: Word = program
+            .get_node_by_id(join_node.first())
+            .expect("first child should exist")
+            .digest()
+            .into();
+        let child2_hash: Word = program
+            .get_node_by_id(join_node.second())
+            .expect("second child should exist")
+            .digest()
+            .into();
+
+        let config = OperationTraceConfig {
+            start_opcode: vm_core::Operation::Join.op_code(),
+            start_hasher_state: (child1_hash, child2_hash),
+            end_node_digest: join_node.digest().into(),
+        };
+
+        self.add_control_flow_trace_row(config, trace_type)
+    }
+
+    /// Adds a trace row for starting a JOIN operation to the main trace fragment.
+    ///
+    /// This is a convenience wrapper around `add_join_trace_row` for JOIN start operations.
+    pub fn add_join_start_trace_row(
+        &mut self,
+        join_node: &JoinNode,
+        program: &vm_core::mast::MastForest,
+    ) -> ControlFlow<()> {
+        self.add_join_trace_row(join_node, program, TraceRowType::Start)
+    }
+
+    /// Adds a trace row for ending a JOIN operation to the main trace fragment.
+    ///
+    /// This is a convenience wrapper around `add_join_trace_row` for JOIN end operations.
+    pub fn add_join_end_trace_row(
+        &mut self,
+        join_node: &JoinNode,
+        program: &vm_core::mast::MastForest,
+    ) -> ControlFlow<()> {
+        self.add_join_trace_row(join_node, program, TraceRowType::End)
+    }
+}

processor/src/parallel/join.rs

@@ -0,0 +1,58 @@
+use core::ops::ControlFlow;
+
+use vm_core::{Word, mast::LoopNode};
+
+use super::{MainTraceFragmentGenerator, TraceRowType, trace_builder::OperationTraceConfig};
+
+impl MainTraceFragmentGenerator {
+    /// Adds a trace row for a LOOP operation (start or end) to the main trace fragment.
+    ///
+    /// This method populates the system, decoder, and stack columns for a single trace row
+    /// corresponding to either the start or end of a LOOP block execution. It uses the
+    /// shared control flow trace building infrastructure.
+    pub fn add_loop_trace_row(
+        &mut self,
+        loop_node: &LoopNode,
+        program: &vm_core::mast::MastForest,
+        trace_type: TraceRowType,
+    ) -> ControlFlow<()> {
+        // For LOOP operations, the hasher state in start operations contains the loop body hash
+        // in the first half, and zeros in the second half (since LOOP only has one child)
+        let body_hash: Word = program
+            .get_node_by_id(loop_node.body())
+            .expect("loop body should exist")
+            .digest()
+            .into();
+        let zero_hash: Word = [vm_core::ZERO; 4];
+
+        let config = OperationTraceConfig {
+            start_opcode: vm_core::Operation::Loop.op_code(),
+            start_hasher_state: (body_hash, zero_hash),
+            end_node_digest: loop_node.digest().into(),
+        };
+
+        self.add_control_flow_trace_row(config, trace_type)
+    }
+
+    /// Adds a trace row for the start of a LOOP operation.
+    ///
+    /// This is a convenience method that calls `add_loop_trace_row` with `TraceRowType::Start`.
+    pub fn add_loop_start_trace_row(
+        &mut self,
+        loop_node: &LoopNode,
+        program: &vm_core::mast::MastForest,
+    ) -> ControlFlow<()> {
+        self.add_loop_trace_row(loop_node, program, TraceRowType::Start)
+    }
+
+    /// Adds a trace row for the end of a LOOP operation.
+    ///
+    /// This is a convenience method that calls `add_loop_trace_row` with `TraceRowType::End`.
+    pub fn add_loop_end_trace_row(
+        &mut self,
+        loop_node: &LoopNode,
+        program: &vm_core::mast::MastForest,
+    ) -> ControlFlow<()> {
+        self.add_loop_trace_row(loop_node, program, TraceRowType::End)
+    }
+}